WebMagic springboot 多站点垂直数据采集（支持插队采集）

已于 2022-02-21 18:21:16 修改
阅读量1.1k 收藏
点赞数
分类专栏： 开源介绍 文章标签： spring boot java 爬虫
于 2022-02-09 20:02:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23287943/article/details/122846964
版权

WebMagic springboot 多站点 垂直 数据采集

webmagic介绍

WebMagic是一个简单灵活的Java爬虫框架。基于WebMagic，你可以快速开发出一个高效、易维护的爬虫。（来自官网介绍）

webmagic 应用

定制 Downloader

/**
 * 自定义下载器，将下载失败的url记录到redis中
 */
@Slf4j
@Component
public class SpiderDownloader extends HttpClientDownloader {

    private static final String DOWNLOAD_START_MILLS = "download_start_mills";
    private static final String DOWNLOAD_EXPAND_MILLS = "download_expand_mills";

    @Override
    public Page download(Request request, Task task) {
        request.putExtra(DOWNLOAD_START_MILLS, System.currentTimeMillis());
        return super.download(request, task);
    }

    @Override
    protected void onSuccess(Request request) {
        super.onSuccess(request);

        calcExpandMills(request);
        log.info("download expand: {} ms, url: {}", request.getExtra(DOWNLOAD_EXPAND_MILLS), request.getUrl());
    }

    @Override
    protected void onError(Request request) {
        super.onError(request);

        calcExpandMills(request);
        log.info("download error!!! expand: {} ms, url: {}", request.getExtra(DOWNLOAD_EXPAND_MILLS), request.getUrl());

        // 将下载失败的url记录到redis

    }

    /**
     * 计算下载耗费毫秒数
     * @param request
     */
    private void calcExpandMills(Request request) {
        long downloadEndMills = System.currentTimeMillis();
        Object downloadStartMills = request.getExtra(DOWNLOAD_START_MILLS);
        if(downloadStartMills != null) {
            long expandMills = downloadEndMills - Long.valueOf(downloadStartMills.toString()).longValue();
            request.putExtra(DOWNLOAD_EXPAND_MILLS, expandMills);
        }
    }
}

定制 Scheduler（基于 redis redisson）

/**
 * 自定义调度器，将下载器传递过来的请求保存到redis中，进行url去重，弹出请求
 */
@Slf4j
@Component
@NoArgsConstructor
public class SpiderRedisScheduler extends DuplicateRemovedScheduler implements MonitorableScheduler, DuplicateRemover {

    /**
     * 用于存放url的队列
     */
    private static final String QUEUE_PREFIX = "queue_";

    /**
     * 用于存放插队url的队列
     */
    private static final String QUEUE_JUMP = "jump_";
    /**
     * 用于对url去重
     */
    private static final String SET_PREFIX = "set_";

    @Resource
    private CrawlerRuleService crawlerRuleService;

    @Autowired
    private RedissonClient redissonClient;


    protected String getSetKey(Task task) {
        return StringUtils.join(RedisKeyConst.spiderKeySpace, SET_PREFIX, task.getUUID());
    }

    protected String getQueueKey(Task task,boolean isJump) {
        return StringUtils.join( RedisKeyConst.spiderKeySpace, (isJump?QUEUE_JUMP:QUEUE_PREFIX), task.getUUID());
    }

    @Override
    public void resetDuplicateCheck(Task task) {
        RSet<Object> urlSet = redissonClient.getSet(getSetKey(task));
        urlSet.delete();
    }

    @Override
    public void push(Request request, Task task) {
        if (this.shouldReserved(request) || this.noNeedToRemoveDuplicate(request) || !isDuplicate(request, task)) {
            this.pushWhenNoDuplicate(request, task);
        }
    }

    @Override
    public boolean isDuplicate(Request request, Task task) {
        RSetCache<Object> urlSet = redissonClient.getSetCache(getSetKey(task));
        boolean has = urlSet.contains(request.getUrl());
        if(Boolean.FALSE.equals(has)) {
            // 将url加入到redis set中
            urlSet.add(request.getUrl(),60, TimeUnit.MINUTES);
            return false;
        } else {
            return true;
        }
    }

    @Override
    protected void pushWhenNoDuplicate(Request request, Task task) {
        CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
        if(null == requestInfo){
            return;
        }
        boolean jump = requestInfo.isJump();
        // 将request推入redis队列中
        RDeque<Object> deque = redissonClient.getDeque(getQueueKey(task,jump));
        Integer type = requestInfo.getType();
        if(CrawlerTypeEnum.CONTENT.getType().equals(type)){
            deque.addLast(request);
            return;
        }
        deque.addFirst(request);
    }

    @Override
    public Request poll(Task task) {
        // 从队列中弹出一个url
        RDeque<Object> jumpDeque = redissonClient.getDeque(getQueueKey(task, true));
        Request request = pollWithStatus(jumpDeque);
        if(null != request){
            return request;
        }
        RDeque<Object> deque = redissonClient.getDeque(getQueueKey(task,false));
        return pollWithStatus(deque);
    }

    private Request pollWithStatus(RDeque<Object> deque){
        while (true){
            Request request = (Request)deque.pollFirst();
            if(request == null) {
                return null;
            }
            CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
            if(null == requestInfo){
                return null;
            }
            CrawlerRule crawlerInfo = crawlerRuleService.getByRuleId(requestInfo.getRuleId());
            if(null == crawlerInfo){
                return null;
            }
            int openStatus = crawlerInfo.getOpenStatus();
            if(openStatus == 0){
                log.info("url:{},规则：{} 被关闭",request.getUrl(),crawlerInfo.getRuleName());
                continue;
            }
            return request;
        }
    }


    @Override
    public int getLeftRequestsCount(Task task) {
        RDeque<Object> jumpDeque = redissonClient.getDeque(getQueueKey(task,true));
        RDeque<Object> deque = redissonClient.getDeque(getQueueKey(task,false));
        return jumpDeque.size() + deque.size();
    }

    public int getLeftRequestsCount(String domain){
        if(StrUtil.isBlank(domain)){
            return 0;
        }
        RDeque<Object> deque = redissonClient.getDeque(RedisKeyConst.spiderKeySpace + QUEUE_PREFIX + domain);
        return deque.size();
    }


    @Override
    public int getTotalRequestsCount(Task task) {
        RSetCache<Object> urlSet = redissonClient.getSetCache(getSetKey(task));
        return urlSet.size();
    }

    public int getTotalRequestsCount(String domain) {
        if(StrUtil.isBlank(domain)){
            return 0;
        }
        RSetCache<Object> urlSet = redissonClient.getSetCache(RedisKeyConst.spiderKeySpace + SET_PREFIX + domain);
        return urlSet.size();
    }


    public void delAllRequest(String domain){
        RDeque<Object> deque = redissonClient.getDeque(RedisKeyConst.spiderKeySpace + QUEUE_PREFIX + domain);
        deque.delete();
        RSetCache<Object> urlSet = redissonClient.getSetCache(RedisKeyConst.spiderKeySpace + SET_PREFIX + domain);
        urlSet.delete();
    }
}

定制 Pipeline

/**
 * @Description: implements Pipeline 数据持久化
 */
@Slf4j
@Component
public class SpiderSavePipLine implements Pipeline {

    @SneakyThrows
    @Override
    public void process(ResultItems resultItems, Task task) {
        Request request = resultItems.getRequest();
        CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
        if(null == requestInfo){
            return;
        }
        Integer type = requestInfo.getType();
        if(CrawlerTypeEnum.DETAIL.getType().equals(type)){
            //详情页信息保存
        }
        if(CrawlerTypeEnum.CONTENT.getType().equals(type)){
            //内容页
          
        }
    }
}

定制 SpiderListener


/**
 * 自定义监听器，统计处理request的成功数和失败数，同时将处理失败的request收集起来
 */
@Component
public class SpiderEventListener implements SpiderListener {
    private final AtomicInteger successCount = new AtomicInteger(0);
    private final AtomicInteger failCount = new AtomicInteger(0);

    private List<Request> failRequests = new CopyOnWriteArrayList<>();

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private CrawlerRuleService crawlerRuleService;

    @Override
    public void onSuccess(Request request) {
        successCount.incrementAndGet();
        CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
        if(null == requestInfo){
            return;
        }
        String countDownSpace = requestInfo.getCountDownSpace();
        if(StrUtil.isNotBlank(countDownSpace)){
            if(null == redissonClient){
                return;
            }
            RCountDownLatch latch = redissonClient.getCountDownLatch(countDownSpace);
            latch.countDown();
        }
    }

    @Override
    public void onError(Request request) {
        failRequests.add(request);
        failCount.incrementAndGet();
    }

    public AtomicInteger getSuccessCount() {
        return successCount;
    }

    public AtomicInteger getFailCount() {
        return failCount;
    }

    public List<Request> getFailRequests() {
        return failRequests;
    }


    /**
     * 根据规则id获取规则信息
     * @param ruleId
     * @return
     */
    private CrawlerRule getCrawlerInfo(String ruleId){
        if(null == ruleId){
            return null;
        }
        CrawlerRule crawlerRule = crawlerRuleService.getByRuleId(ruleId);
        if(StrUtil.isBlank(crawlerRule.getId())){
            return null;
        }
        return crawlerRule;
    }
}

定制 PageProcessor

@Slf4j
@Component
public class SpiderProcessor implements PageProcessor {

    @Resource
    private NovelProcessorFactory novelProcessorFactory;

    @Resource
    private CrawlerRuleService crawlerRuleService;


    @Value("${spider.retryTimes:3000}")
    private int retryTimes = 3000;

    @Value("${spider.sleepTime:3000}")
    private int sleepTime = 3000;

    @Value("${spider.timeOut:60000}")
    private int timeOut = 60000;


    @Override
    public void process(Page page) {
        CrawlerRequestDto requestInfo =
                page.getRequest().getExtra(RequestConst.REQUEST_INFO);
        int type = requestInfo.getType();
        CrawlerRule crawlerInfo = getCrawlerInfo(requestInfo.getRuleId());
        if(null == crawlerInfo){
            return;
        }
        int openStatus = crawlerInfo.getOpenStatus();
        if(openStatus == 0){
            //规则已被关闭
            log.info("规则：{} 被关闭",crawlerInfo.getRuleName());
            return;
        }
        NovelProcessor novelProcessor = novelProcessorFactory.getProcessor(type);
        if(null == novelProcessor){
            return;
        }
        novelProcessor.process(page,requestInfo,crawlerInfo);
    }

    /**
     * 根据规则id获取规则信息
     * @param ruleId
     * @return
     */
    private CrawlerRule getCrawlerInfo(String ruleId){
        if(null == ruleId){
            return null;
        }
        CrawlerRule crawlerRule = crawlerRuleService.getByRuleId(ruleId);
        if(StrUtil.isBlank(crawlerRule.getId())){
            return null;
        }
        return crawlerRule;
    }


    @Override
    public Site getSite() {
        Site site = Site.me().setRetryTimes(retryTimes).setSleepTime(sleepTime).setTimeOut(timeOut);
        site.addHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3");
        site.addHeader("Accept-Encoding", "gzip, deflate");
        site.addHeader("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8");
        site.addHeader("Cache-Control", "max-age=0");
        site.addHeader("Connection", "keep-alive");
//        site.addHeader("Cookie", "Hm_lvt_42e120beff2c918501a12c0d39a4e067=1566530194,1566819135,1566819342,1566963215; Hm_lpvt_42e120beff2c918501a12c0d39a4e067=1566963215");
//        site.addHeader("Host", "www.yousuu.com");
        site.addHeader("Upgrade-Insecure-Requests", "1");
        site.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36");

        return site;
    }
}

根据采集规则获取不同processor

@Component
public class NovelProcessorFactory {

    private static Map<Integer, NovelProcessor> NOVEL_PROCESSOR_MAP = new HashMap<>();

    @Autowired
    private void setProcessorStrategy(
           NovelListProcessor novelListProcessor,
           NovelInfoProcessor novelInfoProcessor,
           NovelContentProcessor novelContentProcessor
    ){
        NovelProcessorFactory.NOVEL_PROCESSOR_MAP.put(
                CrawlerTypeEnum.LIST.getType(),novelListProcessor);
        NovelProcessorFactory.NOVEL_PROCESSOR_MAP.put(
                CrawlerTypeEnum.DETAIL.getType(),novelInfoProcessor);
        NovelProcessorFactory.NOVEL_PROCESSOR_MAP.put(
                CrawlerTypeEnum.CONTENT.getType(),novelContentProcessor);
    }

    public NovelProcessor getProcessor(Integer crawlerType){
        NovelProcessor novelProcessor = NOVEL_PROCESSOR_MAP.get(crawlerType);
        return novelProcessor;
    }
}

定制 Spider

public class SpiderStartContainer extends Spider {

    private SpiderEventListener listener;

    private RedissonClient redissonClient;

    private int status = 0;

    public SpiderStartContainer(PageProcessor pageProcessor, SpiderEventListener listener, RedissonClient redissonClient) {
        super(pageProcessor);
        this.redissonClient = redissonClient;

        List<SpiderListener> spiderListeners = this.getSpiderListeners();
        if(CollectionUtils.isEmpty(spiderListeners)) {
            spiderListeners = new ArrayList<>();
        }
        this.listener = listener;
        spiderListeners.add(listener);
        this.setSpiderListeners(spiderListeners);
    }

    public static SpiderStartContainer create(PageProcessor pageProcessor,SpiderEventListener listener,RedissonClient redissonClient) {
        return new SpiderStartContainer(pageProcessor,listener, redissonClient);
    }

    @Override
    public void run() {
        super.run();
        if(scheduler != null && scheduler instanceof DuplicateRemover) {
            ((DuplicateRemover) scheduler).resetDuplicateCheck(this);
        }
        //爬虫任务完成时处理爬取失败的请求
        List<Request> failRequests = listener.getFailRequests();
        if(CollectionUtils.isNotEmpty(failRequests)) {

        }
    }

    @Override
    public void close() {
        super.close();
        this.status = 3;
    }

    public void spiderClose(String countDownSpace) {
        this.close();
        spiderCountDown(countDownSpace);
    }

    public void spiderStop(String countDownSpace){
        this.stop();
        this.status = this.stat.intValue();
        spiderCountDown(countDownSpace);
    }

    public void spiderStart(){
        spiderStart(null);
    }


    public void spiderStart(String countDownSpace){
        logger.info("===================== check spider:"+this.getUUID()+" status =====================");
        if(this.getSpiderStatus() == 3){
            logger.info("===================== spider:"+this.getUUID()+" is close! spider will be restart! =====================");
            this.spiderStop(null);
        }
        while (this.getSpiderStatus() == 3){
            logger.info("===================== spider:"+this.getUUID()+" is to stop =====================");
        }
        if(this.stat.intValue() == 2 || this.stat.intValue() == 0){
            this.start();

            this.status = this.stat.intValue();
        }
        logger.info("===================== spider:"+this.getUUID()+" is start =====================");
        spiderCountDown(countDownSpace);
    }



    public void spiderJumpQueue(Request request){
        CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
        if(null == requestInfo){
            return;
        }
        requestInfo.setJump(true);
        this.addRequest(request);
        spiderStart();
    }

    public String getSpiderUUID() {
        return this.getUUID();
    }

    public Integer getSpiderStatus(){
        if(status == 3){
            return status;
        }
        return stat.get();
    }

    public int getLeftRequestsCount(String domain){
        SpiderRedisScheduler scheduler = (SpiderRedisScheduler)this.getScheduler();
        if(null != scheduler){
            return scheduler.getLeftRequestsCount(domain);
        }
        return 0;
    }

    public int getTotalRequestsCount(String domain){
        SpiderRedisScheduler scheduler = (SpiderRedisScheduler)this.getScheduler();
        if(null != scheduler){
            return scheduler.getTotalRequestsCount(domain);
        }
        return 0;
    }

    private void spiderCountDown(String countDownSpace){
        if(null == redissonClient){
            return;
        }
        if(StrUtil.isNotBlank(countDownSpace)){
            RCountDownLatch latch = redissonClient.getCountDownLatch(countDownSpace);
            latch.countDown();
        }
    }

}

spider生产者：

@Slf4j
@Configuration
public class SpiderStartContainerFactory {
    @Value("${spider.threadNum:0}")
    private int threadNum;
    /**
     * 线程统一管理
     */
    private static ExecutorService executorService;

    @Resource
    private SpiderProcessor spiderProcessor;

    @Resource
    private SpiderEventListener spiderEventListener;

    @Resource
    private SpiderDownloader spiderDownloader;

    @Resource
    private SpiderRedisScheduler spiderRedisScheduler;

    @Resource
    private SpiderSavePipLine spiderSavePipLine;

    @Resource
    private RedissonClient redissonClient;

    private static final Map<String, SpiderStartContainer> startContainerMap = Collections.synchronizedMap(new HashMap<>());

    public SpiderStartContainer getStartContainer(String domain) {
        if(startContainerMap.get(domain) != null){
            return startContainerMap.get(domain);
        }
        SpiderStartContainer spiderStartContainer =
                SpiderStartContainer.create(spiderProcessor, spiderEventListener, redissonClient);
        spiderStartContainer.setDownloader(spiderDownloader);
        spiderStartContainer.setScheduler(spiderRedisScheduler);
        spiderStartContainer.setPipelines(Collections.singletonList(spiderSavePipLine));
        spiderStartContainer.setExecutorService(executorService);
        startContainerMap.put(domain,spiderStartContainer);
        return spiderStartContainer;
    }

    public SpiderStartContainer getStartContainer(Request request) {
        CrawlerRequestDto requestInfo = request.getExtra(RequestConst.REQUEST_INFO);
        if(null == requestInfo){
            return null;
        }
        UrlBuilder urlBuilder = UrlBuilder.ofHttp(requestInfo.getUrl(), CharsetUtil.CHARSET_UTF_8);
        String domain = urlBuilder.getHost();
        return getStartContainer(domain);
    }

    @PostConstruct
    public void getExecutorService(){
        //线程数 cpu * 2
        if (threadNum == 0) {
            threadNum = Runtime.getRuntime().availableProcessors() * 2;
        }
        log.info("================ spider thread num :{} ================", threadNum);
        SpiderStartContainerFactory.executorService =  Executors.newFixedThreadPool(threadNum);
    }
}

数据采集启动

/**
 * @Description: 采集启动,总线程,集成remote支持远程调用
 */
@Slf4j
@Component
public class SpiderStart implements ApplicationRunner, SpiderContainerRemote,SpiderJobStartRemote {

    @Autowired
    private SpiderStartContainerFactory spiderStartContainerFactory;

    @Resource
    private CrawlerRuleService crawlerRuleService;

    private int status;

    @Override
    public void run(ApplicationArguments args){
        this.start();
    }

    @Override
    public void start() {
        List<CrawlerRule> allRules = crawlerRuleService.getAll();
        List<CrawlerRule> collect = allRules.stream()
                .filter(rule -> rule.getOpenStatus() == 1)
                .collect(Collectors.toList());
        for (CrawlerRule crawlerRule : collect) {
            CrawlerListRule listRule = crawlerRule.getListRule();
            String sourceUrl = listRule.getSourceUrl();
            int pageStartRule = listRule.getPageStartRule();
            String url = sourceUrl.replace(RequestConst.PAGE_REPLACE,pageStartRule+"");
            Request request = new Request(url);
            CrawlerRequestDto requestInfo = CrawlerRequestDto.builder()
                    .url(url)
                    .ruleId(crawlerRule.getRuleId())
                    .type(CrawlerTypeEnum.LIST.getType())
                    .build();
            request.putExtra(RequestConst.REQUEST_INFO,requestInfo);
            SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(getDomain(url));
            spiderStartContainer.addRequest(request);
            spiderStartContainer.spiderStart();
            status = 1;
        }
    }



    @Override
    public int getStarStatus() {
        return this.status;
    }



    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    private String getDomain(String url){
        UrlBuilder urlBuilder = UrlBuilder.ofHttp(url, CharsetUtil.CHARSET_UTF_8);
        return urlBuilder.getHost();
    }

    @Override
    public Integer getSpiderStatus(String domain) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
        if(spiderStartContainer == null){
            return null;
        }
        return spiderStartContainer.getSpiderStatus();
    }

    @Override
    public void spiderClose(String domain, String countDownSpace) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
        spiderStartContainer.spiderClose(null);
    }

    @Override
    public void spiderStop(String domain, String countDownSpace) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
        spiderStartContainer.spiderStop(null);
    }

    @Override
    public void spiderStart(String domain) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
            spiderStartContainer.spiderStart();
    }

    @Override
    public void spiderStart(String domain, String countDownSpace) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
        spiderStartContainer.spiderStart(countDownSpace);
    }

    @Override
    public void spiderJumpQueue(Request request) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(getDomain(request.getUrl()));
        spiderStartContainer.spiderJumpQueue(request);
    }

    @Override
    public void spiderJumpQueue(Request request, String domain) {
        SpiderStartContainer spiderStartContainer = spiderStartContainerFactory.getStartContainer(domain);
        spiderStartContainer.spiderJumpQueue(request);
    }
}

开源地址

github开源地址(飞鸟小说):https://github.com/caobinrg/birds-novel
gitee开源地址(飞鸟小说) : https://gitee.com/caobinrg/birds-novel

飞鸟不过江
关注
专栏目录
【第71题】JAVA高级技术-多线程5（线程插队）
小虚竹的专栏
05-31 3万+
多线程
Java网页爬虫：Spring Boot通过webmagic实现网页爬虫
希尔伯特的博客
01-03 1385
一、需求 因为业务需求，需要实现新闻资讯功能。初步方案通过第三方提供的服务接口来实现此功能。由于谈判失败，因此决定自开发一套爬虫接口。因此通过查询相关文档，决定采用webmagic开源框架实现自己的爬虫功能。 二、实施过程 1、引入依赖 在pom文件中添加依赖： &lt;!-- 爬虫 --&gt; &lt;dependency&gt; &lt;groupId&gt;us.codecr...
第二章 数据采集模块之SpringBoot埋点数据采集（源码 & 资料见文末）
qq_27924553的博客
01-10 2905
数据采集模块之springboot埋点数据采集
SpringBootWeb案例-1
最新发布
readmancynn的博客
08-04 951
前面我们已经完了基础的分页查询，大家会发现：分页查询功能编写起来比较繁琐。查询总记录数指定页码的数据列表在Service当中，调用Mapper接口的两个方法，分别获取：总记录数、查询结果列表，然后在将获取的数据结果封装到PageBean对象中。大家思考下：在未来开发其他项目，只要涉及到分页查询功能(例：订单、用户、支付、商品)，都必须按照以上操作完成功能开发结论：原始方式的分页查询，存在着"步骤固定"、"代码频繁"的问题解决方案：可以使用一些现成的分页插件完成。
WebMagic实现分布式抓取以及断点抓取
weixin_34102807的博客
08-15 307
访问我的博客 前言 从去年到今年，笔者主要负责的是与合作方的内容对接，新增的合作商不是很多的情况下，在我自从去年引入了 WebMagic 这个爬虫框架之后，基本很少需要去关注维护爬虫，做的最多的是新接入合作商去写对应爬虫抓取模板。 因为在代码中实现了增量抓取，单机也足以承担日常的抓取工作。 在前两周，由于公司拓展新的业务渠道，需要接入的合作商瞬间增加了 3 倍，又被要求在 2 天内全部接入，那两天...
SpringBoot+Prometheus采集Metrics指标数据
不会飞的小龙人的博客
06-27 8016
由于metrics维度指标众多，通过prometheus服务采集后，通过数据指标转化成可观察性图形，为应用程序运维提供了合适的监控技术与管理平台，同时也可以将prometheus采集的指标输出到第三方各类平台上进行展示，比如运维中常见的Grafana，提供了许多丰富的图标插件，高大上的的漂亮UI，以及Grafana官网第三方上传的展示模板，可以非常便捷的套用开放模板后立即呈现出可视化监控图形界面；点击菜单栏的“Graph”项，在搜索框中输入jvm，则会自动联想多个带有jvm内容的可观察性指标;
springboot 集成webmagic实现网页数据爬取功能
05-10
springboot 集成webmagic实现网页数据爬取功能 内含项目demo工程 直接导入可使用
数据结构 插队排序
11-19
根据给定的信息，本文将对“数据结构 插队排序”这一主题进行深入解析，并结合实验设计中的朋友组实例来具体展开。 ### 数据结构：插队排序简介 插队排序是一种特殊的排序方法，在这里提到的插队排序并非传统意义...
S7-200SMART进行MODBUS轮询时对写操作进行插队处理具体方法.docx
10-13
在工业自动化领域，西门子S7-200SMART系列PLC经常被用作控制器，而MODBUS通信协议则是连接...这种机制不仅适用于S7-200SMART PLC，也可以应用于其他支持类似功能的PLC，为工业自动化领域的通信管理提供了宝贵的参考。
数据结构课程设计——插队买票
09-13
在数据结构课程设计中，“插队买票”是一个常见的应用场景，它可以帮助我们深入理解各种数据结构的特性和操作。这个项目可能要求学生设计一个模拟系统，允许“顾客”（可以是数字、字符串或其他代表人的标识）按照...
数据结构插队买票.docx
03-09
数据结构插队买票课程设计报告 本文档是关于数据结构课程设计报告，主题为“插队买票”的设计报告。报告的主要内容包括系统需求分析、系统概要设计、系统详细设计、测试等部分。下面是从该报告中提取的相关知识点：...
SpringBoot+JPA+WebMagic
08-25
SpringBoot+JPA+WebMagic+定时器
爬虫基于Springboot+WebMagic+Mybatis+多数据源
11-30
闲来无事最近写了一个全新的爬虫框架WebMagic整合springboot的爬虫程序，不清楚WebMagic的童鞋可以先查看官网了解什么是Webmagic，顺便说说用springboot时遇到的一些坑
SpringBoot处理JSON数据示例代码
07-10
SpringBoot处理JSON数据示例代码,SpringBoot处理JSON数据示例代码
基于JavaGUI+Web Magic爬虫框架实现的医案采集系统.zip
06-19
资源包含文件：lunwen文档+项目源码 用户打开本系统，首先要输入帐号密码，成功通过验证之后，根据用户类型选择进入医生界面或管理员界面。 在医生界面，医生可以选择三种医案录入的方式：手工录入，即医生将病人口述信息以及自己的诊断结果键入文本编辑区；网页爬取，即医生提供包含医案文本的URL，指定爬取规则，系统启动爬虫模块从该网站获取医案文本并导入文本编辑区；图片识别，即医生提供病人以往的病历图片，系统启动识别模块自动将图片中的医案文本识别并导入文本编辑区。最后，医生可将文本编辑区中处理好的结构化文本保存到本地的文本文件中去。 在管理员界面，管理员可将医生处理好的结构化文本导入文本编辑区进行规范化，或将文本导入到预编辑字段，在各个字段中修改。最后，将确认无误的字段导入到数据库中。 详细介绍参考：https://biyezuopin.blog.csdn.net/article/details/125358961
FreeCMS antdv+springboot版 站点管理
vkqiang的专栏
01-10 534
项目地址 http://www.freeteam.cn 站点管理 FreeCMS支持网站群模式,并支持无限树级管理。 站点的相关文件在site目录下，每个站点有自己的文件夹，源文件目录名就是自己的文件夹名称。 添加一级站点 从左侧管理菜单点击站点管理进入。 点击“添加一级站点” 输入相关属性点击“保存”即可。 编辑站点 点击操作列下的编辑 输入相关属性点击“保存”即可。 添加下级站点 点击操作列下的添加子站点 填写
springboot+netty+kafka实现设备信息收集(完整demo复制可用)
todoitbo的博客
04-19 7818
本文将介绍如何利用Spring Boot、Netty和Kafka技术栈构建实时设备信息收集系统。通过详细的实现步骤和案例展示，读者将了解到如何结合这三种技术，实现高效稳定的设备信息采集与处理。
SpringBoot(29) 整合WebMagic实现爬取和解析CSDN文章数据
郑清
07-02 1002
一、前言 WebMagic：一款简单灵活的爬虫框架，基于它我们可以非常容易的编写一个爬虫。 官网地址：http://webmagic.io/docs/zh/ 下面小编将通过爬取+解析自己的csdn文章数据来演示一个简单的爬虫案例demo 二、SpringBoot 整合 WebMagic 1、pom.xml中引入相关依赖 <!-- WebMagic：爬虫 --> <dependency> <groupId>us.codecraft</groupId>
Spring Boot + WebMagic 实现网页爬虫，写得太好了！，零基础如何转行前端开发工程师
2301_79655473的博客
04-04 622
正值金三银四招聘旺季，很多小伙伴都询问我有没有前端方面的面试题，特地整理出来赠送给大家！资料领取方式：点击这里前往免费获取成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-pZxJ8ww7-1712205676762)][外链图片转存中…(img-BFNRRXrp-1712205676762)]
使用散列表解决插队买票问题（多窗口模拟）
"该资源主要涉及散列表（哈希表）在解决‘插队买票’问题中的应用，特别是在多窗口场景下。通过编程实现了一个简单的哈希表结构，并提供了查找和插入元素的方法。" 在计算机科学中，散列表（Hash Table）是一种数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值