文章定时自动采集是一项很有用的技术，它可以帮助网站的管理者从互联网上获取大量的有用信息，并将其存储在本地。最近，优采云推出了一款新的文章定时自动采集软件，它可以帮助网站管理者快速地从互联网上抓取各种信息，并将其存储在本地。
　　
　　优采云的文章定时自动采集软件具有强大的功能，可以帮助网站管理者快速抓取各种信息，包括新闻、博客、图片、视频和音乐。此外，该软件还可以为你提供SEO优化功能，帮助你优化你的网站内容，使之更易于搜索引擎检索。
　　
　　使用优采云的文章定时自动采集软件不需要复杂的步骤，只需要几分钟就可以实现。首先，你需要在官网www.ucaiyun.com 上注册一个优采云账户，然后下载并安装该软件。然后，你就可以根据你的需要来设置不同的采集条目和采集时间间隔。
　　
　　此外，优采云还提供一个强大的数据库，可以帮助你快速找到你想要的信息。该数据库中储存了大量有用的信息，如新闻、博客、图片、视频和音乐。此外，该数据库还能够帮助你对数据进行分类和分析，使之易于理解和使用。
　　总而言之，优采云的文章定时自动采集是一个很好的工具，可以帮助你快速地从互联网上采集大量有用的信息。而且该工具还具备SEO优化功能，可以帮助你优化你的内容使之易于搜索引擎找到并检索出来。如果你想要快速地从互联网上采集信息并整理成有用的内容，那么优采云将是一个很好的选择。 查看全部

　　文章定时自动采集是一项非常有用的工具，它可以帮助网站拥有者节省时间和精力，提高效率，提升网站的流量和质量。优采云是一款强大的文章定时自动采集软件，专为SEO优化而设计，可以帮助网站拥有者实现定时自动采集文章和内容。
　　
　　文章定时自动采集是一项非常有用的工具，能够节省时间和精力，提高效率，提升网站内容的流量和质量。优采云是一款强大的文章定时自动采集工具，专为SEO优化而设计，可以帮助网站拥有者实现定时自动采集文章、图片、图表和其他内容。
　　
　　优采云的特性包括：强大的数据库和信息处理能力；可从各种来源中快速准确地采集新内容；可根据用户的要求进行复杂的数据处理；可对数据进行分析、判断和学习以便进一步优化SEO。此外，优采云还可以利用大数据来帮助用户快速识别和发现新的优化方法。
　　
　　优采云不仅能够帮助用户快速准确地执行新内容的定时自动采集，而且还能够根据用户要求进行复杂的数据分析、判断和学习：用户可以根据不同的情况对数据进行分类、判断、学习并把相关信息应用于SEO优化中；合理使用大数据来识别和发现SEO优化方法。
　　总之，使用优采云这一强大的文章定时自动采集工具将有助于网站所有者在SEO优化中少走弯路、减少错误、快速执行新内容的定时自动采集并提升流量和内容质量。 查看全部

　　文章定时自动采集是指现在的网站内容管理和更新，都可以通过一款名为优采云的软件，来实现定时自动采集文章的功能。优采云是一款面向SEO优化的新型产品，集成了多种功能，可以帮助企业快速实现全面的SEO优化。
　　
　　首先，优采云可以实现文章定时自动采集，也就是说，用户可以在优采云上配置一个关键词或者URL，当有新内容时，优采云就会自动抓取这些内容并添加到用户的网站中，大大减轻了用户手工搜集内容的工作量。此外，用户还可以对新增内容进行校对、整理、格式化，以便将最佳内容放到自己的网站上。
　　
　　其次，优采云还具备SEO优化功能。在使用优采云前，用户可以选择要抓取的关键词或URL，然后进行SEO优化。例如，用户可以设置关键词位置、字数上限、标题样式、文本样式、图片样式等。这样一来，用户就能够将最佳SEO效果显示在自己的网站上。
　　
　　最后，优采云还可以帮助用户快速批量处理内容。当用户将所需要的内容抓取到网站中之后，就可以在优采云上快速批量处理这些内容，例如修改样式、去重、检测垃圾信息等。同时，用户也可以对新增内容进行分类和归档，方便之后的使用。
　　总而言之，使用优采云来实现文章定时自动采集是一个很好的方法。不仅能够帮助用户大大减少手工搜集内容的工作量；而且也能够帮助用户快速批量处理内容并进行SEO优化。如果你想要尝试一下使用优采云来实现文章定时自动采集的效果，可以前往www.ucaiyun.com来注冊使用试试看哦~ 查看全部

　　文章定时自动采集是一种非常有效的文章发布方式，它可以让企业节省大量的时间和精力，更好地推广产品、服务和信息。随着互联网信息日益增多，如何及时准确地采集文章信息成为企业发布文章的必要条件。近年来，由于计算机技术的不断发展，文章定时自动采集已成为企业发布文章的一种方式，也是当前互联网新闻发布领域的一大创新。
　　
　　优采云是一款全新的SEO优化软件，它能够帮助用户快速准确地采集全网各个类别的原创优质文章信息。该软件拥有强大的技术实力，能够将全网原创优质文章以定时自动采集的方式进行采集、整理、分析，并能够将采集到的内容及时的推送到用户手中。
　　
　　此外，该软件还能够根据用户要求对内容进行分类、整理和校对，并提供多样化的数据图表显示，使用户能够快速准确地了解关键词和内容信息。此外，该软件还能够将采集到的原创内容快速有效地同步到各大平台上，使用户能够快速准确地将内容发布出去。
　　
　　此外，优采云还拥有卓越的SEO优化能力。该软件不仅能够快速准确地采集关键词信息，而且还能够根据用户要求对关键词进行优化、利用关键词优化内容、进行SEO优化、监测SEO效果并提供及时效果回馈。
　　总之，优采云是一款先进而专业的SEO优化工具，无论是文章定时自动采集还是SEO优化都能够得心应手地应对。如果你想要快速准确地将原创内容发布出去，那么就来www.ucaiyun.com看看吧! 查看全部

　　文章定时自动采集是企业网络营销的一个重要部分，它能够帮助企业快速、有效地开展网络营销活动，从而提高企业的销售业绩。但是，如何实施文章定时自动采集？本文将介绍一款名为“优采云”的软件，该软件可以帮助企业快速、有效地实施文章定时自动采集。
　　
　　“优采云”是一款专为企业针对网络营销而开发的文章定时自动采集软件。该软件能够帮助企业快速、有效地开展文章定时自动采集活动，进而提升企业的网络营销效果。
　　
　　“优采云”具有多项先进的功能，其中最引人注目的就是SEO优化功能。SEO优化能够有效地帮助企业提升关键词排名，进而吸引更多相关流量。此外，该软件还可以根据用户的需要进行定制化的设置，可以根据用户的特定需要来进行实时抓取和归类，使得新闻内容得到充分利用。
　　
　　此外，“优采云”也可以根据用户需要进行内容分发，将内容分发到各大平台上去，使得用户不必手动去分发内容，大大减少了工作量。
　　总之，“优采云”是一款非常出色的文章定时自动采集工具，可以帮助企业高效、快速地开展文章定时自动采集工作。如果想要详细了解该工具的使用方法和应用场景，可以前往“优采云”的官网www.ucaiyun.com 进行了解。 查看全部

　　文章定时自动采集，是一种非常有效的信息搜集方式，可以有效地帮助企业获取大量相关信息。它能够自动搜索大量网络信息，并将其归类整理后存储到本地数据库中，以便企业快速检索和使用。
　　近年来，随着互联网的发展，文章定时自动采集已成为企业实施SEO优化的重要手段。SEO优化是一项复杂的工作，需要大量的信息和知识来实施。因此，文章定时自动采集能够为SEO优化提供有效的信息和资料，从而帮助企业进行SEO优化工作。
　　
　　然而，手动进行文章定时自动采集是十分耗时、低效的，很多企业都不能承受这样的工作量。因此，出现了“优采云”这样的文章定时自动采集软件，使得SEO优化工作变得更加方便快捷。
　　
　　“优采云”是一款面向SEO优化的文章定时自动采集软件，它能够帮助用户快速、高效地对相关信息进行采集、归类和分析。它可以根据用户要求对关键字、图片、视频、新闻内容进行定时自动采集；并支持用户对所采集内容进行内容分类、核心字词分析、关键词及语义分析等多项内容分析工作。
　　
　　此外，“优采云”还将所有总结出来的信息封装成API形式对外开发使用；后台数据库也能够根据用户要求对所有历史数据进行存储和处理；后端服务器也能够根据不同情况随时改变API的性能及形式。总之，通过“优采云”这样一套文章定时自动采集软件来帮助用户进行SEO优化工作，不但能够大大减少人工介入工作量，而且能够使得SEO优化工作效率大大地得到大幅度的提升。
　　“优采云”是一个覆盖面广泛、性能卓越、易上手易使用的文章定时自动采集软件。不但能够帮助用户快速地将相关信息归类存储到本地数据库中；而且能够帮助用户快速、高效地进行内容分类、核心字词分析、关键词及语义分析等SEO 优化工作。如想了解详情及产品使用方法，可前往“优采云”官方网站 www.ucaiyun.com 浏览相关信息。 查看全部

　　文章定时自动采集是企业网站开发运营中不可缺少的一环，而优采云是一款有效的文章定时自动采集软件，其SEO优化能力更是一绝。
　　随着互联网的发展，信息的流通变得愈加便捷，人们对信息的需求也不断增加，企业在运营中需要大量的内容来吸引受众，而文章定时自动采集正是有效地满足这一需求的方法之一。
　　
　　文章定时自动采集能够帮助企业快速地收集大量原创文章，为企业的信息发布和运营工作提供有效的内容来源。然而，文章定时自动采集不仅仅是要收集大量原创内容，还要考虑如何将新增内容影响最大化。
　　
　　这就是优采云出现的原因。作为一款革命性的新型文章定时自动采集工具，优采云不仅能够快速地帮助企业集成大量原创内容，而且还具有SEO优化能力。
　　
　　首先，优采云可以帮助用户快速、准确地将相关内容从多个来源整合到一体，并根据用户需要对内容进行校正、筛选、分类等处理，从而使用户能够从海量信息中快速找到所需要的内容。
　　此外，优采云还具有强大的SEO优化能力。该工具可以根据用户所选关键词将相应信息进行整合、分类、校正，从而使用户能够得到最佳SEO效果，并对关键词进行相应的分布和权重处理，使得相应信息在百度上得到最佳的SEO效果。
　　总之，作为一款强大的文章定时自动采集工具，优采云不仅能够快速地帮助用户将相关内容整合到一体，而且还具有强大的SEO优化能力。如果你想要尝试使用该工具来帮助你快速地将相关内容影响最大化，请前往www.ucaiyun.com 了解详情。 查看全部

　　文章定时自动采集：如何更高效的实现？
　　现在大多数企业都会在网上发布文章，以吸引更多的用户，这样不仅能提升品牌知名度，还可以提高公司的知名度，但是如何才能更有效的采集文章呢？一般来说，人工采集是最常用的方式，但这种方式存在很多问题。它需要很多时间和人力，耗费了很多精力。
　　
　　幸运的是，随着信息技术的发展，企业可以使用文章定时自动采集工具来实现文章采集。优采云采集器就是其中一款非常好用的工具，该工具可以帮助企业快速采集文章信息。它使用多节点分布式结构，可以同时采集海量新闻、微博、论坛、小说、图片、视频和其他内容。此外，该工具还有一些其他特性，例如安全性强、易于使用、支持API对接和其他功能。
　　使用优采云采集器来实现文章定时自动采集非常方便快捷。首先，你需要去www.ucaiyun.com注册一个账号。然后在“资源库”中添加你想要采集的内容来源。之后就可以进行文章采集了。此外，你还可以根据设置好的时间间隔来设置定时采集任务。当然，你也可以根据你的情况来修改详细的采集规则。通过优采云采集器，你可以快速准确地将想要的内容都采集下来。
　　
　　此外，使用优采云采集器来实现文章定时自动采集还有几个好处。首先，通过使用该工具可以大大减少人工处理数据所耗费的时间成本和人力成本。此外，该工具也能有效地避免因手动数据录入而出现误差或错误的情况。最后，语义分析功能能够根据固定格式判断出数据内容中字符串之间的相对关系。
　　总之，使用优釅云采集器来实现文章定时自动采集能大大减少人工耗费的时间成本和人力成本、避免因手工数据录入而出现误差或错误、并支撑语义分析功能判断出字符串之间相对关系。如想快速准确地将想要的内容都采集下来,就不妨去www.ucaiyun.com注冊一个账号,然后开始使用优釅云采集器,来帮助你快速,高效,省时省心地对新闻、微博、小说、图片、视频和其他内容进行快速,高效,省时省心的文章定时进行超高效的资源预览解压和阅读。 查看全部

　　解决方案:体验优采云采集器带来的便利之道吧~
　　文章定时自动采集，提高效率，节省时间
　　
　　如今，随着信息技术的发展，互联网上的信息越来越丰富。但是，由于信息的不断增多，从中找出有用的信息却几乎成了一项艰巨的任务。如何能够有效获取、管理和利用大量网络信息？为此，优采云采集器应运而生。
　　优采云采集器是一款具有定时自动采集功能的在线数据分析工具。它可以帮助用户快速检索、分类和分析大量的在线数据。此外，它还可以将数据存储在云端，便于用户随时随地访问和使用。
　　
　　优采云采集器非常容易使用：只需要输入相关关键词即可快速定位所需要的内容并收集所有相关文章；用户也可以根据自己的需要对文章进行分类、标注、整理和存储；同时也可以设置定时运行任务来自动采集新内容。另外，优采云采集器还有一个强大的AI引擎，能够根据用户历史行为来学习并智能匹配内容。这样就能帮助用户找到心仪的内容并保存在相应的文件夹中。
　　总之，优采云采集器是一个先进而强大的工具：不仅能帮助人们减少因为内容浏览耗时耗力而得不偿失的情况；还能够节省大量时间来快速准确地找到需要的信息并收集内容。此外，优采云采集器还能够帮助用户将信息存储在云端；并支持定时自动运行任务来获取新内容。因此，优采云采集器是一个有效、便利、快速且省时省力的数据分析工具。如想尝试使用此工具来快速有效获取、管理和使用大量网络信息；请前往www.ucaiyun.com体验优采云采集器带来的便利之道吧~ 查看全部

　　解决方案:如何找到一套出色而靠谱的定时自动采集工具？
　　文章定时自动采集，是企业信息化必备的工具
　　在信息时代，企业不断求新、求变，如何快速、有效的获取需要的信息成为日常管理中的重要课题。定时自动采集在企业信息化中起到十分重要的作用。
　　定时自动采集是一种机器人化的数据获取方式，它能够根据用户预先设置的任务来定期、自动执行相应的采集工作。可以说，它使得批量采集和大数据分析成为了可能。
　　
　　例如，一家电子商务公司想要实时了解行业都有什么促销或者优惠活动，就可以利用定时自动采集这一工具，它能够根据用户预先设置的条件来获取需要的相应信息。同样地，当企业需要大量数据去进行数据分析时，也能够使用这一工具来帮助进行快速而有效地数据采集。
　　然而，如何才能找到一套出色而靠谱的定时自动采集工具呢?这就是众多企业面对的问题。作为一家拥有多年历史的信息化服务商——优采云（）给出了不少好方法。
　　优采云正式上线了一套“文章定时自动采集”工具——“优采云采集器”。其拥有强大而易用的特性：
　　1、超强性能:支撑10W+/天加快内容生产
　　
　　2、超强精准:超精准语义理解,抓取内容减少95%浪费
　　3、超大半径:支撑200+高端内部/外部市场,快速响应市场
　　4、超省心:关注关键词,直击目标内容,精减人员成本
　　5、超易用:高效图形化界面,快速上手,节省学习成本
　　此外，该工具还具备从百度、360、Google等各大平台上批量爬取内容并抓取相应图片和新闻内容等特性。由于是一套web端应用工具，因此不仅方便使用者随时随地进行使用和保存原始数据并抓取相应图片和新闻内容等特性。此外，“优采云采集器”还能根据使用者的使用习惯来不断学习并提升性能,从而最大化使电子商务企业面对各类促销或者优惠活动信息时更便利快速地归类学习. 查看全部

　　内容分享:文案转换为文案，WordPress自动采集软件采集内容翻译伪原创
　　WordPress自动采集软件页面简洁易操作，无需专业规则配置和高级SEO知识即可使用。 无论是WordPress CMS、dede CMS、建站ABC CMS还是小旋风等大大小小的CMS都可以使用。 软件还内置了翻译、发布推送、数据查看等功能。 让我们的WordPress站长通过软件分析数据，实时调整网站优化细节。 我是钱QQ/微信：6439979
　　WordPress自动采集软件可以根据我们输入的关键词采集全网各大平台的内容。 为了提高搜索范围和准确率，支持根据关键词搜索热门下拉词。 下载时支持敏感词过滤和文章清洗。 采集的内容以多种格式（TXT、HTML 和小旋风样式）保存。 支持保留标签、图片本地化等功能，并内置翻译功能，可供有道、百度、谷歌及自带翻译功能使用。
　　用于网站优化的WordPress自动采集软件可以大大减轻我们站长的工作强度。 定时采集让我们可以全天候挂机，网站良好的“作息时间”可以让我们每天更新网站内容，这对蜘蛛来说也是一种友好的行为。
　　当然，光有内容是不够的。 我们需要对内容进行整理，提高内容质量，吸引用户，逐步增加我们的收录量。 WordPress自动采集软件可以通过以下几点优化我们的内容，使我们的网站能够快速收录和完善。 排行。
　　网站内容优化
　　1、文章采集来源质量保证（大平台、热搜词）
　　2.采集内容标签保留
　　
　　3.内置翻译功能（英汉互译，繁简互换，简单到火星文）
　　4.文章清洗（编号、URL、机构名称清洗）
　　3.关键词留存（伪原创不会影响关键词，保证核心关键词的展示）
　　5.在标题和文章中插入关键词
　　6.标题和内容伪原创
　　7.设置内容与标题一致（使内容与标题完全匹配）
　　8.设置关键词自动内链（文章内容中的关键词自动生成内链）
　　9.设置定时释放（实现24小时挂机）
　　一篇好的文章离不开图片的配合。 合理插入与我们文章相关的图片，会大大降低用户的理解难度。 一张好的图片有时可以很吸引眼球，文字却成了一种点缀。 为网站图片添加ALT标签还可以让搜索引擎快速识别图片。 WordPress自动图片采集软件有哪些优化？
　　网站图片优化
　　
　　1、图片云存储（支持七牛、阿里、腾讯等云平台）/本地化
　　2.给图片添加alt标签
　　3.图片替换原图
　　4.图片加水印/去水印
　　5.图片根据出现频率插入文字
　　3.网站管理优化
　　WordPress自动采集软件具有全程优化管理功能。 软件可实现采集、编辑、翻译、伪原创、发布、推送的全流程管理，实时查看各阶段任务进度，反馈任务成功与否。 整合绑定的CMS网站收录、权重、蜘蛛等信息，自动生成曲线供我们分析。
　　作为一名SEO从业者，一定要足够细心，才能做好SEO。 无论是优化文章内容，还是通过alt标签描述图片，每一个细小的地方都可能是我们优化的方向。 在SEO工作中，细心、善于发现、持之以恒是我认为一个好网站必备的要素。 我是钱QQ/微信：6439979
　　本文链接：
　　分享文章:关键字相关文章
　　SEO优化是一个非常繁琐的过程。 虽然总结起来好像没有几个步骤，但是如果你仔细看每一个步骤，你会发现需要做的事情很多，我们不可能面面俱到。 是的，但有些事情我们必须做。 让我们来看看必须做什么。
　　1、合理传播网站关键词密度
　　网站关键词的密度分布也是网站优化的重中之重，但是很多网站优化专家把关键词密度变成了一堆网站关键词。 过度优化导致搜索引擎认为网站作弊，结果不堪设想。
　　通过这两个词的词组，我们很容易将它们组合成一个长尾关键词，比如：网站优化自然排名、新站关键词优化方案、网站关键词优化教程，然后将这些组合词组合成自然分布到网站的标题、阶段和联系信息。
　　
　　2.使用网站标签代码优化关键词
　　如何在网站标签代码中优化自己的网站关键词！ 很多网站优化人员只知道给图片添加alt功能，给flash添加相关的描述。 优化自己网站的关键词。 一个网站的核心关键词只有那么几个，但是一个网站有成百上千个长尾关键词是很常见的。
　　3.合理更新与关键词相关的文章
　　网站优化人员不仅可以在网站的首页、图片、标题、阶段添加长尾关键词，还可以通过网站文章的内容网站大量与网站主题相关的文章，比如:网站优化方案，这个关键词我觉得 如何把自己博客的关键词优化到首页？ 除了之前提到的优化之外，就是更新了很多关于网站优化方案的文章来满足用户的需求。 怀着一颗利他的心，依靠网站尾巴关键词获取流量。
　　四、友情链接和锚链接的注意事项
　　一个网站单从网站内部优化，效果不是很明显。 还可以通过外链加快网站排名效果，更换一些同行业的优质友情链接，更换链接路径，添加一些与自己行业相关的QQ群、论坛、百度贴吧等。都是很好的方法。
　　
　　其实一个网站友情链接的锚链接也是一个很重要的因素。 比如：你是一个动漫网站。 在更换友情链接时，不能总是使用“动漫网站”作为网站的锚链接。 你应该遵循10、5、3比例原则，不要让搜索引擎认为你有过度优化的嫌疑。 网站友情链接控制在​​30个左右为宜。
　　5、网站流量数据分析与转化
　　网站流量的引入是决定网站能否获得排名的直接因素。 不管你的文章有多好，搜索引擎毕竟不是人，只能通过数据来分析网站的用户体验。 一个网站的点击率、用户黏度、跳出率等等都要时时判断。 所以高梁搜索引擎优化说，想要你的网站有好的排名，文章更新后，你必须要有流量，多少IP适合流量。 之前做过测试，关键词搜索指数是1/2。 网站控制在40%左右。
　　以上就是我在SEO搜索优化中必须要做的几点。 以上内容是我个人的一些看法。 如有不同意见，欢迎交流。 最后，希望我的分享能对你有所帮助。
　　摘要：特客网专注于SEO搜索优化优化、搜索优化技术、关键词密度训练。 成都SEO技术服务外包公司提供SEO优化培训和百度关键词排名优化服务。 查看全部

　　技巧:js中两种定时器，setTimeout和setInterval的区别
　　setTimeout只在指定时间后执行一次，代码如下：
　　
//定时器 异步运行
function hello(){
alert("hello");
}
//使用方法名字执行方法
var t1 = window.setTimeout(hello,1000);
<p>
var t2 = window.setTimeout("hello()",3000);//使用字符串执行方法
window.clearTimeout(t1);//去掉定时器
</p>
　　setInterval以指定时间为周期循环执行，代码如下：
　　//实时刷新时间单位为毫秒
setInterval(&#39;refreshQuery()&#39;,8000);
/* 刷新查询 */
function refreshQuery(){
$("#mainTable").datagrid(&#39;reload&#39;,null);
<p>
}</p>
　　这两种方式是根据不同的场景和业务需求来选择的。
　　一般来说，setTimeout 用于延迟方法或函数的执行，
　　setInterval一般用于刷新表单，针对某些表单的false实时指定时间刷新同步
　　销毁两个定时器方法：
　　//清除超时计时器，
　　传入id（定时器创建时会返回一个id） clearTimeout(i);
　　//清除间隔计时器，
　　传入id（定时器创建时会返回一个id） clearInterval(j);
　　方法和技巧:站外SEO优化需要掌握哪些技巧？
　　搜索引擎优化主要围绕站内seo、站外seo和搜索体验优化三个主要步骤展开，每一步都非常重要。 要想做好搜索引擎优化，获得更多的目标客户，就必须坚持以客户为中心，以客户转化价值最大化为中心，围绕满足用户需求、遵守搜索引擎规则进行科学规范的SEO运营. 今天跟大家分享一下：站外SEO优化可以加速关键词排名的提升。
　　搜索引擎优化流程图
　　1、什么是站外SEO优化？
　　网站外SEO优化是指对网站进行外部优化，旨在充分暴露网站URL链接、锚文本和品牌信息的SEO运营方案。 暴露网站URL的目的是为了增加搜索引擎蜘蛛抓取网站的机会，锚文本是为了增强网站的相关性，更多的品牌信息出现在公共媒体上，更有利于客户对网站的认可品牌。
　　站外SEO优化流程
　　2、如何做站外SEO？ 有哪些 SEO 技巧？
　　1.增加网站URL链接的曝光度
　　增加网站链接曝光也称为链接资源导入，目的是增加搜索引擎蜘蛛抓取网站的机会，提高快照收录率，增加快照评级的概率。 让多个公共链接汇聚在一个点（网站），增加页面权重，页面权重越高，排名就会越高。
　　2. 带有锚文本的链接更有意义
　　锚文本，也称为锚文本链接，是链接的一种形式。 与超链接类似，超链接的提示代码是一个锚文本，以关键词或主题作为链接指向特定的网页。 这种形式的链接称为锚文本。 锚文本链接不仅可以增加网页被收录的几率，还可以判断链接的相关性。 相关性越强，关键词排名就越好。
　　
　　3.建立优质友情链接
　　与您的网站交换链接的权威网站称为“优质友情链接”。 评价一个网站是否权威，最简单的方法就是看网站的百度权重。 其次，可以看看网站当天收录的网页快照的数量和及时收录。 注意，质量越高。
　　比如马云说“邢清涛是我马云的朋友”，因为马云是公众人物，这句话出自马云之口，权威性自然就高； 如果我说“马云是邢清涛的朋友”，那权威性自然会下降很多； 如果马云和邢清涛同时这么说，哪个更权威，这就是友情链接的双向性。 因此友情链接的建立最好是双向的、相关的，搜索引擎给网站的评价越高。
　　3.清除垃圾外链和垃圾友链
　　很多站长为了优化网站，购买了大量的高权重外链和友情链接，结果并没有达到链接传输的目的。 没有坚持正确的SEO操作的主要原因如下：
　　1.链接质量不够好
　　凡是卖链接的网站，在搜索引擎中一般都会有特殊标记（异常或被屏蔽）。 由于本网站的链接始终在不断变化，导致网站站在搜索引擎中的友好度降低或被屏蔽；
　　2.内容相关性不强
　　站长选择链接质量指标只看表面权重和收录量是错误的。 他们必须选择内容匹配的网站进行链接建设；
　　3.链接持续时间太短
　　一般购买链接的站长几个月内看不到关键词排名有任何变化就会被下架。 众所周知，前期可能已经违反了前面的三个基本原则，链路评估周期一般在3-6个月；
　　
　　4.建立链接的方法不对
　　很多站长随便找一些媒体，发一些锚文本扩展，都指向网站首页。 我们需要根据引导链接内容的相关性来定义锚文本，链接要指向相关内容，而不是指向网站。 一般友情链接与首页URL交换，内容外链对应实际内容URL；
　　4.站外SEO策略方案
　　网站优化最难的绝对不是技巧，也不是策略，而是SEO实施的可行性。 相信大部分优化师都知道SEO的操作步骤和思路。 难点在于有效实施……一般来说，一种方法、一种经验或一种SEO策略，只要一步步实施，就不会差太远。 关键是你不一定能用到这些资源，也不一定有能力继续执行，而大多数优化者都希望快速解决问题，所以对问题的考虑自然是不全面的。
　　1.友情链接SEO策略
　　为您的会员链接选择一个名称很重要，这不是随机选择。 我们需要选择靠近网站标题左端的关键词作为友情链接的名称，或者选择网站的品牌名称作为友情链接的名称。 许多网站管理员每次交换友好链接时都会更改链接名称。 这是SEO的大忌，很容易降低搜索引擎对网站的友好度。
　　2.外链SEO策略
　　外部链接一般分为纯文本外部链接和锚文本链接。 因为很多外部平台不能给内容加上超链接，所以确实可以引用纯文本的外部链接。 纯文本外链对网页收录仍然有影响，但对快照评分没有影响； 最有价值的是锚文本超链接，因为锚文本可以帮助搜索引擎分析链接的相关性。 搜索引擎根据关键词和相关性、内容质量、显示量、点击量、内容及时性和用户可用性进行综合判断，对URL进行快照评级。
　　四。 概括
　　站外优化SEO实施确实有一定的困难，但我们不能利用搜索引擎规则欺骗客户来实现快速排名，必须坚持科学的SEO操作规则，以用户价值最大化为中心，解决用户的实际需求。 正式 SEO 操作的起点。 即使通过SEO黑帽可以达到关键词排名的目的，也绝不是长久之计，迟早要付出代价的。 查看全部

　　解决方案:苹果cms 8X设置定时任务 自动采集 自动生成静态
　　执行参数：make-index
　　执行参数介绍：
　　生成视频首页make-index
　　生成文章首页 make-index-tab-art
　　生成视频地图 make-map
　　生成文章图 make-map-tab-art
　　生成视频主题首页 make-topicindex-tab-vod
　　生成文章主题首页 make-topicindex-tab-art
　　
　　生成Google xml make-rss-ac2-google-googleall-5000-google-1000 [googleall的总输出，每页google的数量]
　　生成百度xml make-rss-ac2-baidu-baiduall-5000-baidu-1000 [百度总输出，百度每页数量]
　　生成rss make-rss-ac2-rss-rss-1000 [每页rss数]
　　生成自定义页面make-label-ids-label_js.html【label_js.html为自定义页面文件名】
　　================================================ ================================================ ========================================
　　生成当天更新数据的视频分类make-type-tab-vod【id为视频分类的id】
　　生成当天更新数据的文章分页make-type-tab-art【id为文章分类的id】
　　================================================ ================================================ =========================================
　　生成视频主题列表make-topic-tab-vod-ids-13【id为视频分类的id】
　　
　　生成文章主题列表make-topic-tab-art-ids-13【id为文章分类的id】
　　===================== 以下任务每次最多生成100条数据，避免长期占用系统资源======== ======== ==
　　生成未生成的视频数据 make-info-tab-vod-ac2-nomake
　　生成未生成的文章数据 make-info-tab-art-ac2-nomake
　　当天生成更新视频数据 make-info-tab-vod-ac2-day
　　生成当天更新的文章数据 make-info-tab-art-ac2-day
　　本文标题：苹果cms 8X设置定时任务自动采集自动生成静态
　　本文链接：
　　解决方案:苹果CMS系统建站安装步骤
　　Apple CMS是一个成熟稳定的资源管理系统，可以用来建立自己的影视网站。 现在网上有大量的在线观影网站，其中很大一部分是用Apple CMS搭建的。 一键建站、配置简单、资源采集方便等优点。 这是有关构建 Apple CMS 系统以及如何配置它的教程。
　　安装苹果内容管理系统
　　首先在百度上搜索Apple CMS，进入官网下载官方安装包。
　　然后上传到你的后台根目录下解压。 解压后在浏览器访问域名/admin.php进入后台安装界面，如下图：
　　
　　然后，点击“同意协议并安装系统”，进入如下环境监控界面。 安装程序会检查你的vps上安装的插件是否符合Apple CMS的要求。 只有满足要求，Apple CMS才能正常运行，所以这一步检测是必须的。
　　当然，既然是测试环境，当然会有一些不符合要求的检查项目。 如果任何项目不符合要求，它将用红色突出显示的丝带标记。 一般测试失败是因为系统缺少一些插件，按照提示安装需要的插件即可。 当这一步的所有测试都成功后，就可以点击“下一步”按钮，进入如下界面：
　　这里的数据库信息要根据你MySQL中的实际配置填写。 目的是让Apple CMS通过这些参数登录到你的MySQL。 只有这样Apple CMS才能使用数据库来读写需要的数据。
　　
　　下面的管理员账号密码是您以后登录Apple CMS后台所需要的用户名和密码。 请设置一个足够长、足够安全、不易被破解的密码，并记住。
　　最后点击“立即安装”按钮，稍等片刻即可安装成功。 此时在浏览器中输入域名就可以看到Apple CMS的首页（也就是前台界面）。 该页面是外界访问您的站点时看到的主页。
　　在浏览器中输入域名/admin.php，即可登录Apple CMS后台管理界面。 在后台管理页面，可以进行与站点相关的所有设置，包括采集视频、设置播放器、更改模板、设置SEO优化等，这部分内容非常复杂。 只有视频数据采集成功后，你的网站才会有内容，别人才能看到你网站上的视频，否则你的网站就是空洞的，没有任何实质内容。
　　这里只简单介绍一下如何采集系统自带资源站的数据，步骤如下：
　　采集时可能会报错“category is not bound”。 这是因为您站点上的电影类别与资源站点上的电影类别之间没有一一对应关系。 因此，Apple CMS 并不知道资源站点上的类别 A 对应于您站点上的哪个类别。 此时只需要绑定分类即可。 这些操作并不难，稍微摸索一下就可以上手。 查看全部

　　解决方案:HZIRS网络雷达检索系统
　　一般政府事务
　　网站信息雷达与检索系统是集信息采集、信息全文检索等综合信息处理为一体的信息资源集成服务系统，包括雷达子系统和全文检索子系统，提供网站采集、检索和信息集成服务。
　　1 适用范围
　　◆网络媒体：自动跟踪采集国内外网络媒体信息，可采用关键词过滤搜索或批量采集，实现对各类新闻的有效采集、分类、编辑、管理、发布、检索一体化；
　　◆ 党政机关：实时采集与业务工作相关的信息资源或新闻，在内网或外网实时动态发布，满足上班族对互联网信息的需求，提高办公和工作效率。
　　◆大型企事业单位：通过系统实时跟踪采集行业政策、宏观环境、竞争对手等相关信息，有利于提升企业综合竞争力。
　　◆特别适用于需要站内搜索功能的各级企业、政府网站、门户网站，尤其适用于网站群的信息采集和检索。
　　整个系统具有完善的系统管理功能，提供用户和用户组的管理、权限设置和系统参数配置。 雷达子系统侧重于信息的采集和对采集到的信息的处理和利用。 检索子系统侧重于检索采集的信息。 根据系统配置，可以设置采集的信息是否仅供检索。
　　还需要对内容进行智能化处理，将其保存为其他格式的数据库或内容库，通过接口与内容管理紧密结合，扩展内容管理系统的采集和检索功能。 系统可以直接建立各种资源信息中心，建立门户网站搜索或网站组搜索。
　　下面主要介绍两个子系统
　　2 雷达子系统
　　
　　雷达子系统主要采用链接分析技术和网页智能分析技术，实现对目标网站信息的监控和智能采集。 它可以通过设置采集关键词，准确、高效地从广大的网络站点中获取有价值的信息，同时提供对信息的加工处理。 通过分发处理，信息可以直接传送到内容管理系统和其他信息平台，成为信息的来源。
　　该系统具有以下特点
　　2.1 J2EE技术​​框架
　　采用先进的技术框架，跨平台运行
　　2.2 基于智能视觉的内容抽取技术
　　无需繁琐的设置，系统根据人对信息的视觉检查，智能提取文字和标题，系统自动去除广告等无用信息，智能提取有价值的信息内容。 许多其他类型的产品需要用户为每个站点进行复杂的设置，这既昂贵又不便维护。
　　2.3 支持关键词采集
　　可设置多个主题关键词，采集过程中只采集与关键词匹配的信息，便于获取更准确、更有价值的信息。
　　2.4 分类别、多站点采集
　　允许创建分类对站内采集对象进行管理和分类，支持站内采集范围，精确到整个网站、特定栏目、特定页面，允许设置站内采集深度和采集链接特征。
　　2.5 支持多种文档格式
　　支持采集文中图片，可设置是否采集文中出现的图片，可采集DOC、PPT、PDF等格式文件。
　　2.6采集信息管理
　　对采集的信息进行集中展示和管理，提供按站点和分类浏览信息，提供在线编辑、修改和删除，并可灵活分发到内容管理系统。
　　
　　2.7 多线程并发，采集速度快
　　通过多线程处理技术，系统可以同时采集多个搜索引擎，快速高效采集目标站点或栏目信息。
　　2.8 增量采集和自动采集
　　提供多种运行方式，对变更信息只能进行增量采集，可手动和自动运行。 通过设置定时任务，可以定时采集，实现无人值守的维护更新模式。
　　2.9 开放数据接口
　　采用XML数据接口，允许与其他系统进行数据交换。
　　3采集性能
　　每分钟抓取数百个最新页面（与机器性能和网络带宽有关）
　　支持上百个站点的采集和管理
　　标题文字智能提取准确率达到90%以上
　　4 检索子系统
　　全文搜索是网站群系统的一项重要功能。 沉阳软件开发在多个站点、大量的信息和各种格式的信息之间进行快速、方便。
　　沉阳软件开发、沉阳软件公司&quot; /&gt;
　　解决方案:站群seo优化做建站的误区以及如何避免
　　一：防止所有内容雷同。 很多做网站站群站长的人并没有那么多时间去创作原创内容，有的甚至采集搞假原创内容。 网站结构和内容的相似度接近99%。 这样的网站自然很容易被识别出来。 所以在内容建设上，一定要多做假原创，多花时间，让网站内容之间的差异尽可能小。 获得超过50%！
　　
　　二：网站的主机IP地址相同。 很多人为了节省成本，选择在同一个IP服务器下制作成百上千个内容相同的网站。 这类网站自然容易识别，一般不超过200个网站站群，ip地址一定要不同，除非超过200个网站，同一个ip下最多只能有四个网站，而且这四个网站不能相互联系！
　　三：所有网站关键词都一样，一般是很多网站站群的共性。 这时候想办法把关键词变成各种长尾词，这样搜索引擎就可以无规律了。 跟随！
　　四：网站模板不要雷同。 许多网站管理员喜欢使用相同的cms程序，以节省建站时间。 其实网上有很多种。 免费模板来做到这一点！
　　
　　五： 外链的建设不能所有网站都一样。 必须有改变。 一定要为自己的资源给每个网站分配不同的外链资源，这样才能避免搜索引擎发现！
　　六：站群之间的网站一定不能互相网站。 这有点不切实际，而且很容易被搜索引擎识别，因为一个网站不可能同时获得那么多的全站连接，但是我们可以对内容相关的网页做链接，这是很自然的，不能同时被搜索引擎识别！
　　同时，做站群最重要的是选择多段混C多IP站群服务器，这样即使一个网站整个IP都是K，其IP段下的网站也会不受影响 查看全部

　　汇总:WordPress 采集插件：优采云采集
　　插件介绍
　　优采云()是一款通用、简单、智能的在线网页数据采集发布平台Wordpress采集插件。
　　主要特点：
　　1、采集无需安装任何客户端或插件，无需研究网页源代码，只需在线选择、点击、保存，即可实现采集；
　　2、提供强大的SEO工具，包括：文字插入动态段落（强烈推荐）、文字插入段落和标题自动关键词、标题插入关键词、自动内链、同义词替换、简繁体转换、翻译等（伪原创) ;
　　
　　3、支持采集微信公众号文章（含公众号历史文章）、今日头条采集、综合新闻采集，只需输入微信公众号名称或ID或关键词即可采集；
　　4、智能识别数据和规则，包括：列表页、翻页和详情页（标题、正文、作者、发布时间等）；
　　5、定时采集更新，自动发布； 定期发布和站群发布；
　　6、灵活强大的数据二次处理工具；
　　7、图片可下载到（阿里云OSS、七牛对象存储、腾讯云COS、优拍云），打通防盗链；
　　8、多节点分布式采集、免费IP代理等机制；
　　
　　9、与其他采集器相比，有优采云采集器更简单易用，功能同样强大，没有复杂的流程；
　　10.书签一键采集发布：随时随地，看到好文章，点击浏览器书签采集发布第三方网页内容到您的网站！
　　插件下载
　　WordPress采集插件：优采云采集下载地址：
　　安装使用
　　下载Wordpress采集插件：优采云采集，然后进入网站后台，点击“插件”-“安装插件”，上传你下载的插件即可使用。
　　汇总:文章自动采集-文章自动采集自动发布
　　文章自动采集,文章自动采集生成,文章自动采集软件
　　关于文章自动采集内容导航： 1.文章采集采集采集文章是一件坏事。 是采集的一大忌讳。 建议发贴者不要这样做。 编辑一下，也就是做个伪原创。 只有这样，才能提高文章的可读性。 当然，蜘蛛最喜欢的是原创，可以提升用户体验。 这是最好的文章。 建议楼主三思行。
　　2.文章自动采集，自动发布
　　1. 注册账号
　　打开优采云采集官网，注册一个账号：
　　2.创建爬虫
　　进入有优采云，点击“添加爬虫”，选择“去市场搜索”；
　　找到要使用的规则模板后，单击免费获取。
　　
　　3.管理爬虫
　　在控制面板中，找到已建立的爬虫任务，点击“管理”；
　　进入主菜单-概览后，点击右上角“启动牛汉服”；
　　任务运行一段时间后，可以在主菜单-爬取结果中看到采集的数据。
　　4.发布数据
　　1）安装插件：
　　首先在您的网站上安装有财优采云WeCenter发布插件；
　　安装方法是将ap、system、most views三个文件夹上传到网站根目录，同时更新插件时也需要将这三个文件夹都上传到根目录；
　　2）发布设置：
　　进入管理爬虫界面，在“数据发布&amp;引导”中填写发布信息；
　　
　　注意：发布到文章和问答模块时选择的界面不同；
　　3）数据发布
　　主菜单-爬取沈冰冰照片结果，怕声音，作音，望然，选择发布；
　　付费会员可在采集结果右上角勾选“自动送肉尽可能多”，点此查看会员价和三权限。
　　3、文章自动采集软件是网站新闻采集器吗？好像真的很好用，不是免费的
　　行业热点：【文章自动采集与自动发布】【文章自动采集软件】【文章自动采集系统】【文章自动采集发布在百家】【文章自动采集与生成】【文章自动采集插件下载] [文章自动采集器] [文章自动采集发布收费] [文章自动采集怎么做] [文章自动采集发布]
　　即将到来的假期：11 月的万圣节！ 再忙也要善待自己！
　　文章自动采集文章采集采集文章自动发布！ 查看全部

　　汇总:【简易数据分析 09 | Web Scraper 自动控制抓取数量 & Web
　　
　　这是简单数据分析系列的第16文章。 在本课程中，我们将介绍一个用得比较少的Web Scraper功能——抓取属性信息。 当一个网页显示信息的时候，除了我们看到的，其实还有很多隐藏的信息。 以豆瓣电影250为例： 当电影画面正常显示时，是这样的： 如果网络异常导致图片加载失败，则显示默认的副本图片。 这个copy其实就是图片的属性信息： 我们看一下这个结构的HTML（查看方法见第一节CSS选择器的使用），我们会发现图片的默认copy其实就是这个
　　
　　标签的alt属性...
　　汇总:全网最简单的数据采集自动化工具
　　“网络爬虫”这个词大家都耳熟能详，了解它的朋友都听过“好爬虫早早入狱”的说法。 其实，任何一个工具，如果合理使用，都会极大地帮助用户提高效率，但如果使用过多，则会产生负面影响，在此。 “网络爬虫”本身的实际含义是“代替人自动采集整理互联网上的数据信息”。 说白了，“网络爬虫”的核心其实就是“数据采集自动化”技术。 ”这是一个不好的词。在这里，我希望用“自动化数据采集”来代替它。通过一种简单的方式，每个人都可以在工作和生活中根据自己的需要采集网络公共数据，并实现自动采集的技术。
　　今天给大家带来的是我认为是全网最简单的爬虫工具——即时数据采集器
　　这是一个浏览器插件，主要运行环境是带有Chome内核的浏览器，比如Chrome浏览器，
　　Edge浏览器、360极速浏览器等，这个工具之所以是最简单的数据采集自动化工具，它有以下优点：
　　安装方式一：应用市场安装
　　以Edge浏览器为例，教你安装Instant Data Scraper
　　打开Microsoft Edge浏览器扩展市场，搜索Instant Data Scraper
　　Edge 浏览器扩展搜索 Instant Data Scraper 结果
　　3. 获取 Instant Data Scraper 并添加扩展
　　也可以通过Instant Data Scraper直接安装在Edge expansion market的网页上。 以上各省区搜索步骤链接如下：
　　安装方法二：离线安装最新版本的Instant Data Scraper，扩展文件为crx。 我已经上传到蓝座网盘了。 可以打开Edge浏览器管理扩展页面（本地链接edge://extentsions）打开开发者模式。
　　打开边缘浏览器开发者模式
　　
　　4. 意志
　　将Instant_Data_Scraper_v1.0.8.crx文件拖放到Edge浏览器管理扩展页面并安装扩展
　　上述方法不仅适用于Edge浏览器、Chrome浏览器等国内Chrome内核的浏览器，但扩展应用市场能否搜索到还不确定，尤其是Chrome浏览器需要特殊的方式接入扩展应用市场，所以在应用市场无法安装的情况下，建议通过第二种方式安装。
　　安装后的最终效果会在浏览器扩展管理页面看到，部分浏览器默认会显示在扩展栏中，有如下标识显示
　　Instant Data Scraper扩展栏展示
　　如何使用 Instant Data Scraper
　　关于Instant Data Scraper的使用，我会通过几个不同的使用场景来介绍，不仅是教大家如何使用Instant Data Scraper，而且通过不同场景的使用，将类似的数据获取方式整合起来。
　　通过Instant Data Scraper采集【豆瓣电影Top250】数据并保存到本地表
　　学过python爬虫的朋友都知道，在学习python爬虫技术的时候，基本都会用豆瓣电影Top250作为实例测试，而python可能是初学者获取豆瓣电影Top250数据的敲门砖。 让我们通过Instant Data Scraper来看看豆瓣电影Top250是多么容易。
　　打开豆瓣固定Top250页面
　　2、点击Instant Data Scraper插件，自动识别当前页面的数据，并以表格形式实时展示。 同时可以直接进行相关编辑，比如修改第一行的标题，删除不需要的数据列等，得到豆瓣电影Top250第一页的内容已经完美得到
　　Instant Data Scraper获取豆瓣电影250条数据
　　这是我第一次打开 Instant Data Scraper 页面。 由于界面是英文的，所以页面上其实没有任何内容。 这里我用截图来翻译一下整个Instant Data Scraper界面的大概含义和功能。
　　
　　Instant Data Scraper页面介绍
　　3、定位“下一页”元素通过分页获取数据操作：点击“定位‘下一页’按钮”进入元素选择模式（鼠标所在位置会显示绿色阴影），选择“下一页”元素用鼠标（本页选“后页”，其他网站不一定，观察点一下会自动跳到下一页）
　　Instant Data Scraper 选择下一页
　　4.选择“下一页”元素时，将显示原创“位置&#39;next&#39;按钮”作为“开始爬行”符号，这意味着选择了分页选择模式。 点击“开始爬取”开始爬取。 如果“下一页”元素选择错误，可以直接再次点击“下一页”元素标记。
　　Instant Data Scraper 开始抓取数据
　　不同的网站会设置连续翻页的时间间隔来限制反爬。 Instant Data Scraper 的默认时间间隔是 1-20 秒的随机时间延迟。 为了以后使用，可以根据需要定制。 没有时间限制，可以减少最大的延迟时间来加速取数据。
　　5. 当出现如上截图时，表示爬取数据结束。 选择适当的格式以下载结果。 如果没有特殊要求，建议下载XLSX常用的office表格格式，方便进一步的数据筛选、编辑等操作。
　　Instant Data Scraper数据采集端页面
　　资料下载打开后，可以看到全部250条影视信息的详细列表。 你可以进行其他相关操作，比如设置第一行为想要的标题，删除不需要的内容等。同时，你还可以根据其他需要进行数据筛选，数据透视表等操作。
　　通过实际操作，你应该会发现通过Instant Data Scraper获取数据是多么的简单。 以获取豆瓣250条数据为例，及时通过Python编写爬虫脚本也需要时间，但通过Instant Data Scraper获取数据，只需点击几下，是不是最简单的数据获取工具？
　　当然，Instant Data Scraper 绝对不是万能的。 对于要求更高的用户，或者获取的内容不一定是自己需要的，Instant Data Scraper暂时做不到。 最大的限制应该是不能自定义，纯傻瓜式操作，即时数据采集器最大的优势也是傻瓜式操作，可以自动获取数据，基本满足大部分人日常办公生活的需求和其他场景。
　　关注我，下一期将为大家介绍如何在其他场景使用Instant Data Scraper，比如电商平台、图片网站等。同时，我也会为大家带来更多其他的“数据采集自动化”技术。人群 是没有编程基础或者只是在日常工作场景中使用简单数据采集的人群居多。 查看全部

　　解决方案:定时任务模块，附带定时采集实现
　　今天终于实现了定时任务模块。 发完我们一起优化吧，代码如下，你看不看，就在那儿:)
　　代码清单：
　　================================ SQL================= === ==================
　　日程
　　=================================定时任务模块类============= ===== =====================
　　计划管理DAO接口CmsSchedulerDao.java
　　计划管理DAO接口实现类CmsSchedulerDaoImpl.java
　　定时任务管理服务接口CmsSchedulerMng.java
　　定时任务管理服务接口实现类CmsSchedulerMngImpl.java
　　定时任务管理接口SchedulerTaskManageSvc.java
　　定时任务管理接口实现类SchedulerTaskManageSvcImpl.java
　　定时任务接口SchedulerTaskSvc.java
　　定时任务抽象实现类AbstractSchedulerTaskSvc.java
　　定时任务接口-采集器实现类-多线程版SchedulerAcquisitionSvcImpl.java
　　定时服务关联任务be​​anSchedulerTaskBean.java
　　定时任务ControllerCmsSchedulerAct.java
　　持久对象基类 BaseCmsScheduler.java
　　持久对象 CmsScheduler.java
　　HBM 文件 CmsScheduler.hbm.xml
　　===================================定时任务模块相关互助=========== ==== ========================
　　规划框架
　　规划框架-任务调度Scheduler.java
　　规划框架——时间生成器接口ScheduleIterator.java
　　定时任务抽象类SchedulerTask.java
　　调度框架-时间生成器接口实现类SimpleScheduleIterator.java
　　调度参数beanScheduleParamBean.java
　　采集相关
　　HTML解析工具类接口ParseHtmlTool.java
　　HTML解析工具，HtmlParser实现类HtmlParserImpl.java
　　采集参数封装beanParamBean.java
　　队列.java
　　URL 队列 UrlQueue.java
　　接下来是XML配置
　　=================================定时任务模块XML配置=========== ===== =======================
　　道配置
　　管理配置
　　服务配置
　　接下来是messages_zh_CN.properties添加的常量
　　================================ messages_zh_CN.properties=============== ==== ====================
　　messages_zh_CN.properties
　　接下来是模板
　　================================模板================= ==== ==================
　　generate_left.html 已被修改
　　调度程序/add.html
　　调度程序/edit.html
　　调度程序/list.html
　　具体代码如下：
　　================================ SQL================= === ==================
　　1：计划任务表
　　/*
MySQL Data Transfer
Source Host: localhost
Source Database: jeecms
Target Host: localhost
Target Database: jeecms
Date: 2011-11-8 11:36:55
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for jc_scheduler
-- ----------------------------
CREATE TABLE `jc_scheduler` (
`scheduler_id` int(11) NOT NULL AUTO_INCREMENT COMMENT &#39;任务主键&#39;,
`site_id` int(11) DEFAULT NULL,
`associate_id` int(11) DEFAULT NULL COMMENT &#39;相关ID&#39;,
`module_type` varchar(100) DEFAULT NULL COMMENT &#39;模块类型&#39;,
`name` varchar(100) DEFAULT NULL COMMENT &#39;任务名称&#39;,
`start_time` datetime DEFAULT NULL COMMENT &#39;开始时间&#39;,
`end_time` datetime DEFAULT NULL COMMENT &#39;结束时间&#39;,
`status` int(1) NOT NULL DEFAULT &#39;0&#39; COMMENT &#39;当前状态(0:静止;1:采集)&#39;,
`expression` varchar(50) NOT NULL COMMENT &#39;计划表达式&#39;,
PRIMARY KEY (`scheduler_id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records
-- ----------------------------
INSERT INTO `jc_scheduler` VALUES (&#39;4&#39;, &#39;1&#39;, &#39;1&#39;, &#39;schedulerAcquisitionSvc&#39;, &#39;测试&#39;, &#39;2011-11-07 18:02:30&#39;, &#39;2011-11-07 18:04:00&#39;, &#39;0&#39;, &#39;*,*,*,*,3,0&#39;);
INSERT INTO `jc_scheduler` VALUES (&#39;8&#39;, &#39;1&#39;, &#39;5&#39;, &#39;schedulerAcquisitionSvc&#39;, &#39;测试采集java&#39;, &#39;2011-11-08 10:25:15&#39;, &#39;2011-11-08 10:27:04&#39;, &#39;0&#39;, &#39;*,*,*,*,26,0&#39;);
INSERT INTO `jc_scheduler` VALUES (&#39;9&#39;, &#39;1&#39;, &#39;1&#39;, &#39;schedulerAcquisitionSvc&#39;, &#39;测试采集新闻&#39;, &#39;2011-11-08 10:37:58&#39;, &#39;2011-11-08 10:38:11&#39;, &#39;0&#39;, &#39;*,*,*,*,38,0&#39;)
　　=================================定时任务模块类============= ===== =====================
　　计划管理DAO接口CmsSchedulerDao.java
　　package com.jeecms.cms.dao.assist;
import java.util.List;
import com.jeecms.cms.entity.assist.CmsScheduler;
import com.jeecms.common.hibernate3.Updater;
/**
* 计划管理DAO接口
* @author javacoo
* @since 2011-11-07
*/
public interface CmsSchedulerDao {
public List getList();
public List getListBy(CmsScheduler bean);
public CmsScheduler findById(Integer id);
public CmsScheduler save(CmsScheduler bean);
public CmsScheduler updateByUpdater(Updater updater);
public CmsScheduler deleteById(Integer id);
}
　　计划管理DAO接口实现类CmsSchedulerDaoImpl.java
　　package com.jeecms.cms.dao.assist.impl;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Repository;
import com.jeecms.cms.dao.assist.CmsSchedulerDao;
import com.jeecms.cms.entity.assist.CmsScheduler;
import com.jeecms.common.hibernate3.Finder;
import com.jeecms.common.hibernate3.HibernateBaseDao;
@Repository
public class CmsSchedulerDaoImpl extends
HibernateBaseDao implements CmsSchedulerDao {
@SuppressWarnings("unchecked")
public List getList() {
Finder f = Finder.create("from CmsScheduler bean order by bean.id asc");
return find(f);
}
@SuppressWarnings("unchecked")
public List getListBy(CmsScheduler bean) {
Finder f = Finder.create("from CmsScheduler bean");
if(StringUtils.isNotEmpty(bean.getModuleType()) && bean.getSite().getId() != null) {
f.append(" where bean.moduleType=:moduleType and bean.site.id=:siteId");
f.setParam("moduleType", bean.getModuleType());
f.setParam("siteId", bean.getSite().getId());
}
f.append(" order by bean.id asc");
return find(f);
}
public CmsScheduler findById(Integer id) {
CmsScheduler entity = get(id);
return entity;
}
public CmsScheduler save(CmsScheduler bean) {
getSession().save(bean);
return bean;
}
public CmsScheduler deleteById(Integer id) {
CmsScheduler entity = super.get(id);
if (entity != null) {
getSession().delete(entity);
}
return entity;
}
@Override
protected Class getEntityClass() {
return CmsScheduler.class;
}
}
　　定时任务管理服务接口CmsSchedulerMng.java
　　package com.jeecms.cms.manager.assist;
import java.util.List;
import com.jeecms.cms.entity.assist.CmsScheduler;
/**
* 计划任务管理服务接口
* @author javacoo
* @since 2011-11-07
* @version 1.0
*/
public interface CmsSchedulerMng {
/**
* 取得所有计划任务
* @return 所有计划任务
*/
List getList();
/**
* 取得指定站点，指定模块所有计划任务
* @param bean 计划任务bean
* @return 所有计划任务
*/
List getListBy(CmsScheduler bean);
/**
* 根据ID取得计划任务
* @param id
* @return 计划任务
*/
CmsScheduler findById(Integer id);
/**
* 停止指定的计划任务
* @param id
*/
void stop(Integer id);
/**
* 开始指定的计划任务
* @param id
*/
CmsScheduler start(Integer id);
/**
* 停止指定的计划任务
* @param id
*/
void end(Integer id);
/**
* 保存计划任务
* @param bean
* @return
*/
CmsScheduler save(CmsScheduler bean);
/**
* 更新计划任务
* @param bean
* @return
*/
CmsScheduler update(CmsScheduler bean);
/**
* 删除计划任务
* @param bean
* @return
*/
CmsScheduler deleteById(Integer id);
/**
* 批量删除计划任务
* @param bean
* @return
*/
CmsScheduler[] deleteByIds(Integer[] ids);
}
　　定时任务管理服务接口实现类CmsSchedulerMngImpl.java
　　package com.jeecms.cms.manager.assist.impl;
import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jeecms.cms.dao.assist.CmsSchedulerDao;
import com.jeecms.cms.entity.assist.CmsAcquisition;
import com.jeecms.cms.entity.assist.CmsScheduler;
import com.jeecms.cms.manager.assist.CmsSchedulerMng;
import com.jeecms.common.hibernate3.Updater;
/**
* 计划任务管理服务接口实现类
* @author javacoo
* @since 2011-11-07
* @version 1.0
*/
@Service
@Transactional
public class CmsSchedulerMngImpl implements CmsSchedulerMng{
@Transactional(readOnly = true)
public List getList() {
return dao.getList();
}
@Transactional(readOnly = true)
public List getListBy(CmsScheduler bean) {
return dao.getListBy(bean);
}
@Transactional(readOnly = true)
public CmsScheduler findById(Integer id) {
CmsScheduler entity = dao.findById(id);
return entity;
}
public void stop(Integer id) {
CmsScheduler acqu = findById(id);
if (acqu == null) {
return;
}
if (acqu.getStatus() == CmsScheduler.START) {
acqu.setStatus(CmsScheduler.STOP);
}
}
public CmsScheduler start(Integer id) {
CmsScheduler scheduler = findById(id);
if (scheduler == null) {
return scheduler;
}
scheduler.setStatus(CmsAcquisition.START);
scheduler.setStartTime(new Date());
scheduler.setEndTime(null);
return scheduler;
}
public void end(Integer id) {
CmsScheduler scheduler = findById(id);
if (scheduler == null) {
return;
}
scheduler.setStatus(CmsAcquisition.STOP);
scheduler.setEndTime(new Date());
}
public CmsScheduler save(CmsScheduler bean) {
bean.init();
dao.save(bean);
return bean;
}
public CmsScheduler update(CmsScheduler bean) {
Updater updater = new Updater(bean);
bean = dao.updateByUpdater(updater);
return bean;
}
public CmsScheduler deleteById(Integer id) {
CmsScheduler bean = dao.deleteById(id);
return bean;
}
public CmsScheduler[] deleteByIds(Integer[] ids) {
CmsScheduler[] beans = new CmsScheduler[ids.length];
for (int i = 0, len = ids.length; i < len; i++) {
beans[i] = deleteById(ids[i]);
}
return beans;
}
private CmsSchedulerDao dao;
@Autowired
public void setDao(CmsSchedulerDao dao) {
this.dao = dao;
}
}
　　定时任务管理接口SchedulerTaskManageSvc.java
　　package com.jeecms.cms.service.scheduler;
import java.util.List;
import com.jeecms.cms.entity.assist.CmsScheduler;
/**
* 定时任务管理接口
* @author javacoo
* @since 2011-11-07
*/
public interface SchedulerTaskManageSvc {
/**
* 开始计划任务
* @param scheduler 任务对象
* @return true/false
*/
boolean start(CmsScheduler scheduler);
/**
* 结束计划任务
* @param scheduler 任务对象
* @return true/false
*/
boolean stop(CmsScheduler scheduler);
/**
* 取得关联任务map
* @param scheduler 任务对象
* @return 关联任务map
*/
List associateTaskList(CmsScheduler scheduler);
}
　　定时任务管理接口实现类SchedulerTaskManageSvcImpl.java
　　package com.jeecms.cms.service.scheduler;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.jeecms.cms.entity.assist.CmsScheduler;
import com.jeecms.common.scheduling.core.Scheduler;
import com.jeecms.common.scheduling.core.SchedulerTask;
import com.jeecms.common.scheduling.impl.ScheduleParamBean;
import com.jeecms.common.scheduling.impl.SimpleScheduleIterator;
/**
* 定时任务管理服务接口实现类
* @author javacoo
* @since 2011-11-07
*/
@Service
public class SchedulerTaskManageSvcImpl implements SchedulerTaskManageSvc {
/**任务管理对象MAP*/
private static Map taskManageMap = new ConcurrentHashMap();
/**定时任务服务对象MAP*/
@Autowired
private Map schedulerTaskSvcMap;
/**
* 任务管理对象
* @author javacoo
* @since 2011-11-07
*/
private class TaskManage{
/**任务调度*/
private final Scheduler scheduler = new Scheduler();
/**任务参数bean*/
private ScheduleParamBean scheduleParamBean;
/**定时任务*/
private final SchedulerTaskSvc schedulerTaskSvc;
private CmsScheduler cmsScheduler;
public TaskManage(SchedulerTaskSvc schedulerSvc,CmsScheduler cmsScheduler){
this.schedulerTaskSvc = schedulerSvc;
this.cmsScheduler = cmsScheduler;
}
/**
* 解析计划表达式
* @return
*/
private boolean parseSchedulerParam(){
scheduleParamBean = new ScheduleParamBean();
System.out.println("计划表达式："+cmsScheduler.getExpression());
String schedulerParamStr = cmsScheduler.getExpression();
if(StringUtils.isNotEmpty(schedulerParamStr) && schedulerParamStr.contains(",")){
String[] strAarr = schedulerParamStr.split(",");
if(strAarr.length == 6){
if(StringUtils.isNumeric(strAarr[0])){
scheduleParamBean.setWeekOfMonth(Integer.valueOf(strAarr[0]));
}
if(StringUtils.isNumeric(strAarr[1])){
scheduleParamBean.setDayOfWeek(Integer.valueOf(strAarr[1]));
}
if(StringUtils.isNumeric(strAarr[2])){
scheduleParamBean.setDayOfMonth(Integer.valueOf(strAarr[2]));
}
if(StringUtils.isNumeric(strAarr[3])){
scheduleParamBean.setHourOfDay(Integer.valueOf(strAarr[3]));
}
if(StringUtils.isNumeric(strAarr[4])){
scheduleParamBean.setMinute(Integer.valueOf(strAarr[4]));
}
if(StringUtils.isNumeric(strAarr[5])){
scheduleParamBean.setSecond(Integer.valueOf(strAarr[5]));
}
}else{
return false;
}
}else{
return false;
}
return true;
}
/**
* 开始
*/
public void start() {
if(parseSchedulerParam()){
scheduler.schedule(new SchedulerTask() {
public void run() {
processer();
}
private void processer() {
System.out.println("============开始执行计划任务=================");
schedulerTaskSvc.start(cmsScheduler);
}
}, new SimpleScheduleIterator(scheduleParamBean));
}
}
/**
* 取消
*/
public void cancel() {
schedulerTaskSvc.stop(cmsScheduler);
scheduler.cancel();
}

}
/**
* 开始执行计划
* @param scheduler 计划对象
*/
public boolean start(CmsScheduler scheduler) {
SchedulerTaskSvc schedulerSvc = getSchedulerTaskSvcByModuleType(scheduler.getModuleType());
TaskManage taskManage = new TaskManage(schedulerSvc,scheduler);
taskManage.start();
taskManageMap.put(scheduler.getId(), taskManage);
return true;
}
/**
* 停止执行计划
* @param scheduler 计划对象
*/
public boolean stop(CmsScheduler scheduler) {
TaskManage taskManage = taskManageMap.get(scheduler.getId());
taskManage.cancel();
return true;
}
/**
* 取得计划关联的任务对象集合
* @param scheduler 计划对象
*/
public List associateTaskList(CmsScheduler scheduler) {
SchedulerTaskSvc schedulerSvc = getSchedulerTaskSvcByModuleType(scheduler.getModuleType());
return schedulerSvc.associateTaskList(scheduler);
}
/**
* 根据模块的类型，取得定时任务服务对象
* @param moduleType 模块类型
*/
private SchedulerTaskSvc getSchedulerTaskSvcByModuleType(String moduleType){
return schedulerTaskSvcMap.get(moduleType);
}
}
　　定时任务接口SchedulerTaskSvc.java
　　package com.jeecms.cms.service.scheduler;
import java.util.List;
import com.jeecms.cms.entity.assist.CmsScheduler;
/**
* 定时任务接口
* @author javacoo
* @since 2011-11-04
*/
public interface SchedulerTaskSvc {
/**
* 开始计划任务
* @param cmsScheduler 任务对象
* @return true/false
*/
boolean start(CmsScheduler cmsScheduler);
/**
* 结束计划任务
* @param cmsScheduler 任务对象
* @return true/false
*/
boolean stop(CmsScheduler cmsScheduler);
/**
* 取得关联任务map
* @param cmsScheduler 任务对象
* @return 关联任务map
*/
List associateTaskList(CmsScheduler cmsScheduler);
}
　　定时任务抽象实现类AbstractSchedulerTaskSvc.java
　　package com.jeecms.cms.service.scheduler;
import java.util.List;
import com.jeecms.cms.entity.assist.CmsScheduler;
/**
* 定时任务抽象实现类
* @author javacoo
* @since 2011-11-08
*/
public abstract class AbstractSchedulerTaskSvc implements SchedulerTaskSvc{
/**
* 开始计划任务
* @return true/false
*/
public boolean start(CmsScheduler scheduler){
return execute(scheduler);
}
/**
* 开始计划任务
* @return true/false
*/
public boolean stop(CmsScheduler scheduler){
return true;
}
/**
* 取得关联任务map
* @return 关联任务map
*/
public List associateTaskList(CmsScheduler scheduler){
return null;
}
protected abstract boolean execute(CmsScheduler scheduler);
}
　　定时任务接口-采集器实现类-多线程版SchedulerAcquisitionSvcImpl.java
　　package com.jeecms.cms.service.scheduler;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.HttpResponseException;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.jeecms.cms.entity.assist.CmsAcquisition;
import com.jeecms.cms.entity.main.Content;
import com.jeecms.cms.manager.assist.CmsAcquisitionMng;
import com.jeecms.common.crawler.UrlQueue;
import com.jeecms.common.crawler.util.HtmlParserImpl;
import com.jeecms.common.crawler.util.ParseHtmlTool;
/**
* 计划任务接口-采集器实现类-多线程版
* @author javacoo
* @since 2011-11-02
* @version 1.0
*/
@Service
public class SchedulerAcquisitionSvcImpl extends AbstractSchedulerTaskSvc {
private Logger log = LoggerFactory.getLogger(SchedulerAcquisitionSvcImpl.class);
/**开启线程数*/
private static int THREAD_NUM = 2;
/**每个线程休眠毫秒数*/
private static int SLEEP_TIME = 100;
/**连接集合标志*/
private static String LINK_KEY = "linkKey";
/**标题集合标志*/
private static String TITLE_KEY = "titleKey";
/**采集管理对象*/
private CmsAcquisitionMng cmsAcquisitionMng;
/**存放HttpClient的ThreadLocal对象*/
private static ThreadLocal httpClientThreadLocal = new ThreadLocal();
/**存放ParseHtmlTool的ThreadLocal对象*/
private static ThreadLocal parseHtmlToolThreadLocal = new ThreadLocal();
/**存放UrlQueue的ThreadLocal对象*/
private static ThreadLocal urlQueueThreadLocal = new ThreadLocal();
/**存放计划UrlQueue的ThreadLocal对象*/
private static ThreadLocal planUrlQueueThreadLocal = new ThreadLocal();
@Autowired
public void setCmsAcquisitionMng(CmsAcquisitionMng cmsAcquisitionMng) {
this.cmsAcquisitionMng = cmsAcquisitionMng;
}
@Override
protected boolean execute(CmsScheduler scheduler) {
CmsAcquisition acqu = cmsAcquisitionMng.findById(scheduler.getAssociateId());
if (acqu == null) {
return false;
}
System.out.println("===============开始执行采集任务");
new Thread(new MainThreadProcesser(this,acqu)).start();
return true;
}
/**
* 取得关联任务map
* @return 关联任务map
*/
public List associateTaskList(CmsScheduler scheduler){
List list = cmsAcquisitionMng.getList(scheduler.getSite().getId());
List resultList = new ArrayList();
SchedulerTaskBean schedulerTaskBean = null;
for(CmsAcquisition acquisition : list){
schedulerTaskBean = new SchedulerTaskBean();
schedulerTaskBean.setId(acquisition.getId());
schedulerTaskBean.setName(acquisition.getName());
resultList.add(schedulerTaskBean);
}
return resultList;
}
/**
* 主线程处理类
* @author javacoo
* @since 2011-11-02
*/
private class MainThreadProcesser implements Runnable {
private CmsAcquisition acqu;
private SchedulerTaskSvc schedulerAcquisitionSvc;
public MainThreadProcesser(SchedulerTaskSvc schedulerAcquisitionSvc,CmsAcquisition acqu) {
this.acqu = acqu;
this.schedulerAcquisitionSvc = schedulerAcquisitionSvc;
}
//线程锁
Object threadLock = new Object();
public void run() {
long tStart = System.currentTimeMillis();
System.out.println("主线程："+Thread.currentThread().getName() + "开始...");
try {
CountDownLatch latch = new CountDownLatch(THREAD_NUM);
ExecutorService exec = Executors.newCachedThreadPool();
getHttpClient().getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,new HttpHost("128.160.64.5", 1235));
CharsetHandler handler = new CharsetHandler(acqu.getPageEncoding());
//取得当前任务所有计划
getAllPlans(acqu,getPlanUrlQueue());
//开启一线程执行抓取计划下URL
Thread thread = new Thread(new FetchUrlThread(schedulerAcquisitionSvc,latch,getHttpClient(),getPlanUrlQueue(),getUrlQueue(),getParseHtmlTool(acqu),handler,threadLock));
exec.execute(thread);
//开启指定数目线程执行采集内容
for(int i=0;i= 0; i--) {
planMap.put(LINK_KEY, plans[i]);
planMap.put(TITLE_KEY, acqu.getName());
addUrlAndTitleMap(planMap,urlQueue);
}
System.out.println("=======当前线程："+Thread.currentThread().getName() + "计划URL连接数："+urlQueue.getUnVisitedUrlNum());
}
/**
* 取得当前线程下所有计划的连接，并加入队列
* @param acqu 采集参数对象
* @param handler 字符集对象
* @param urlQueue 队列
* @throws URISyntaxException
* @throws IOException
* @throws ClientProtocolException
*/
private void getAllUrls(HttpClient httpClient,ParseHtmlTool parseHtmlTool,CharsetHandler handler,UrlQueue urlQueue,Map map) throws URISyntaxException, ClientProtocolException, IOException{
HttpGet httpGet = new HttpGet(new URI(map.get(LINK_KEY).trim()));
String html = httpClient.execute(httpGet, handler);
for(Map planMap : parseHtmlTool.getUrlAndTitleMap(html)){
addUrlAndTitleMap(planMap,urlQueue);
}
System.out.println("=======当前线程："+Thread.currentThread().getName() + "URL连接数："+urlQueue.getUnVisitedUrlNum());
}
/**
* 保存内容
* @param acqu 请求参数对象
* @param httpClient httpClient对象
* @param parseHtmlTool parseHtmlTool对象
* @param handler CharsetHandler对象
* @param map 连接和标题map对象
* @return Content
*/
private synchronized Content saveContent(CmsAcquisition acqu,HttpClient httpClient,ParseHtmlTool parseHtmlTool,CharsetHandler handler,Map map) {
try {
HttpGet httpGet = null;
if(map.get(LINK_KEY).contains("http://")){
httpGet = new HttpGet(new URI(map.get(LINK_KEY).trim()));
}else{
httpGet = new HttpGet(new URI("http://localhost/v7/"+map.get(LINK_KEY).trim()));
}
String html = httpClient.execute(httpGet, handler);
System.out.println("=============================子线程："+Thread.currentThread().getName() + "执行");
String txt = parseHtmlTool.getHtml(html);
//return cmsAcquisitionMng.saveContent(map.get(TITLE_KEY), txt,acqu.getId());
return null;
} catch (Exception e) {
log.warn(null, e);
e.printStackTrace();
return null;
}
}
/**
* 字符集帮助类
* @author Administrator
*
*/
private class CharsetHandler implements ResponseHandler {
private String charset;
public CharsetHandler(String charset) {
this.charset = charset;
}
public String handleResponse(HttpResponse response)
throws ClientProtocolException, IOException {
StatusLine statusLine = response.getStatusLine();
if (statusLine.getStatusCode() >= 300) {
throw new HttpResponseException(statusLine.getStatusCode(),
statusLine.getReasonPhrase());
}
HttpEntity entity = response.getEntity();
if (entity != null) {
if (!StringUtils.isBlank(charset)) {
return EntityUtils.toString(entity, charset);
} else {
return EntityUtils.toString(entity);
}
} else {
return null;
}
}
}
}
　　定时服务关联任务be​​anSchedulerTaskBean.java
　　package com.jeecms.cms.service.scheduler;
/**
* 定时服务关联任务bean
* @author javacoo
* @since 2011-11-07
*/
public class SchedulerTaskBean {
/**任务主键*/
private Integer id;
/**任务名称*/
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
　　定时任务ControllerCmsSchedulerAct.java
　　package com.jeecms.cms.action.admin.assist;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import com.jeecms.cms.entity.assist.CmsAcquisition;
import com.jeecms.cms.entity.assist.CmsScheduler;
import com.jeecms.cms.entity.main.CmsSite;
import com.jeecms.cms.manager.assist.CmsSchedulerMng;
import com.jeecms.cms.manager.main.CmsLogMng;
import com.jeecms.cms.service.scheduler.SchedulerTaskManageSvc;
import com.jeecms.cms.service.scheduler.SchedulerTaskBean;
import com.jeecms.cms.web.CmsUtils;
import com.jeecms.cms.web.WebErrors;
/**
* 计划任务Controller
* @author javacoo
* @since 2011-11-7
*/
@Controller
public class CmsSchedulerAct {
private static final Logger log = LoggerFactory
.getLogger(CmsSchedulerAct.class);
/**日志服务*/
@Autowired
private CmsLogMng cmsLogMng;
/**计划管理服务*/
@Autowired
private CmsSchedulerMng manager;
/**计划任务管理服务*/
@Autowired
private SchedulerTaskManageSvc schedulerTaskManageSvc;
@RequestMapping("/scheduler/v_list.do")
public String list(HttpServletRequest request, ModelMap model) {
List list = manager.getList();
model.addAttribute("list", list);
return "scheduler/list";
}
@RequestMapping("/scheduler/v_listBy.do")
public String listBy(String moduleType,HttpServletRequest request, ModelMap model) {
CmsSite site = CmsUtils.getSite(request);
CmsScheduler scheduler = new CmsScheduler();
scheduler.setModuleType(moduleType);
scheduler.setSite(site);
List list = manager.getListBy(scheduler);
model.addAttribute("list", list);
model.addAttribute("moduleType", moduleType);
return "scheduler/list";
}
@RequestMapping("/scheduler/v_add.do")
public String add(String moduleType,HttpServletRequest request, ModelMap model) {
CmsSite site = CmsUtils.getSite(request);
CmsScheduler scheduler = new CmsScheduler();
scheduler.setModuleType(moduleType);
scheduler.setSite(site);
List schedulerTaskList = schedulerTaskManageSvc.associateTaskList(scheduler);
model.addAttribute("schedulerTaskList", schedulerTaskList);
model.addAttribute("moduleType", moduleType);
return "scheduler/add";
}
@RequestMapping("/scheduler/v_edit.do")
public String edit(Integer id, HttpServletRequest request, ModelMap model) {
WebErrors errors = validateEdit(id, request);
if (errors.hasErrors()) {
return errors.showErrorPage(model);
}
CmsSite site = CmsUtils.getSite(request);
CmsScheduler scheduler = manager.findById(id);
scheduler.setSite(site);
List schedulerTaskList = schedulerTaskManageSvc.associateTaskList(scheduler);
model.addAttribute("schedulerTaskList", schedulerTaskList);
model.addAttribute("cmsScheduler", scheduler);
return "scheduler/edit";
}
@RequestMapping("/scheduler/o_save.do")
public String save(CmsScheduler bean,HttpServletRequest request, ModelMap model) {
CmsSite site = CmsUtils.getSite(request);
bean.setSite(site);
bean = manager.save(bean);
model.addAttribute("moduleType", bean.getModuleType());
log.info("save CmsScheduler id={}", bean.getId());
cmsLogMng.operating(request, "cmsAcquisition.log.save", "id="
+ bean.getId() + ";name=" + bean.getName());
return "redirect:v_listBy.do";
}
@RequestMapping("/scheduler/o_update.do")
public String update(CmsScheduler bean, HttpServletRequest request, ModelMap model) {
WebErrors errors = validateUpdate(bean.getId(), request);
if (errors.hasErrors()) {
return errors.showErrorPage(model);
}
bean = manager.update(bean);
log.info("update CmsAcquisition id={}.", bean.getId());
cmsLogMng.operating(request, "cmsAcquisition.log.update", "id="
+ bean.getId() + ";name=" + bean.getName());
return listBy(bean.getModuleType(),request, model);
}
@RequestMapping("/scheduler/o_delete.do")
public String delete(String moduleType,Integer[] ids, HttpServletRequest request,
ModelMap model) {
WebErrors errors = validateDelete(ids, request);
if (errors.hasErrors()) {
return errors.showErrorPage(model);
}
CmsScheduler[] beans = manager.deleteByIds(ids);
for (CmsScheduler bean : beans) {
log.info("delete CmsAcquisition id={}", bean.getId());
cmsLogMng.operating(request, "cmsScheduler.log.delete", "id="
+ bean.getId() + ";name=" + bean.getName());
}
return listBy(moduleType,request, model);
}
@RequestMapping("/scheduler/o_start.do")
public String start(Integer id, HttpServletRequest request,
HttpServletResponse response, ModelMap model) {
CmsScheduler scheduler = manager.findById(id);
schedulerTaskManageSvc.start(scheduler);
manager.start(id);
model.addAttribute("moduleType", scheduler.getModuleType());
log.info("start CmsAcquisition id={}", id);
return "redirect:v_listBy.do";
}
@RequestMapping("/scheduler/o_end.do")
public String end(Integer id, HttpServletRequest request,
HttpServletResponse response, ModelMap model) {
manager.end(id);
CmsScheduler scheduler = manager.findById(id);
schedulerTaskManageSvc.stop(scheduler);
model.addAttribute("moduleType", scheduler.getModuleType());
log.info("end CmsScheduler id={}", id);
return "redirect:v_listBy.do";
}
private WebErrors validateEdit(Integer id, HttpServletRequest request) {
WebErrors errors = WebErrors.create(request);
CmsSite site = CmsUtils.getSite(request);
if (vldExist(id, site.getId(), errors)) {
return errors;
}
return errors;
}
private WebErrors validateUpdate(Integer id, HttpServletRequest request) {
WebErrors errors = WebErrors.create(request);
CmsSite site = CmsUtils.getSite(request);
if (vldExist(id, site.getId(), errors)) {
return errors;
}
return errors;
}
private WebErrors validateDelete(Integer[] ids, HttpServletRequest request) {
WebErrors errors = WebErrors.create(request);
CmsSite site = CmsUtils.getSite(request);
if (errors.ifEmpty(ids, "ids")) {
return errors;
}
for (Integer id : ids) {
vldExist(id, site.getId(), errors);
}
return errors;
}
private boolean vldExist(Integer id, Integer siteId, WebErrors errors) {
if (errors.ifNull(id, "id")) {
return true;
}
CmsScheduler entity = manager.findById(id);
if (errors.ifNotExist(entity, CmsAcquisition.class, id)) {
return true;
}
return false;
}
}
　　持久对象基类 BaseCmsScheduler.java
　　package com.jeecms.cms.entity.assist.base;
import java.io.Serializable;
import java.util.Date;
public abstract class BaseCmsScheduler implements Serializable {
public static String REF = "CmsScheduler";
public static String PROP_ID = "id";
public static String PROP_SITE = "site";
public static String PROP_ASSOCIATE_ID = "associateId";
public static String PROP_MODULE_TYPE = "moduleType";
public static String PROP_NAME = "name";
public static String PROP_START_TIME = "startTime";
public static String PROP_END_TIME = "endTime";
public static String PROP_STATUS = "status";
public static String PROP_EXPRESSION = "expression";
// constructors
public BaseCmsScheduler () {
initialize();
}
/**
* Constructor for primary key
*/
public BaseCmsScheduler (java.lang.Integer id) {
this.setId(id);
initialize();
}

public BaseCmsScheduler(Integer id,String name, Date startTime, Date endTime,
Integer status, Integer associateId, String moduleType, String expression,com.jeecms.cms.entity.main.CmsSite site) {
super();
this.id = id;
this.name = name;
this.startTime = startTime;
this.endTime = endTime;
this.status = status;
this.associateId = associateId;
this.moduleType = moduleType;
this.expression = expression;
this.site = site;
}
protected void initialize () {}
private int hashCode = Integer.MIN_VALUE;
// primary key
private java.lang.Integer id;
// fields
private java.lang.String name;
private java.util.Date startTime;
private java.util.Date endTime;
private java.lang.Integer status;
private java.lang.Integer associateId;
private java.lang.String moduleType;
private java.lang.String expression;
private com.jeecms.cms.entity.main.CmsSite site;
public int getHashCode() {
return hashCode;
}
public void setHashCode(int hashCode) {
this.hashCode = hashCode;
}
public java.lang.Integer getId() {
return id;
}
public void setId(java.lang.Integer id) {
this.id = id;
}
public java.lang.String getName() {
return name;
}
public void setName(java.lang.String name) {
this.name = name;
}
public java.util.Date getStartTime() {
return startTime;
}
public void setStartTime(java.util.Date startTime) {
this.startTime = startTime;
}
public java.util.Date getEndTime() {
return endTime;
}
public void setEndTime(java.util.Date endTime) {
this.endTime = endTime;
}
public java.lang.Integer getStatus() {
return status;
}
public void setStatus(java.lang.Integer status) {
this.status = status;
}
public java.lang.Integer getAssociateId() {
return associateId;
}
public void setAssociateId(java.lang.Integer associateId) {
this.associateId = associateId;
}
public java.lang.String getModuleType() {
return moduleType;
}
public void setModuleType(java.lang.String moduleType) {
this.moduleType = moduleType;
}
public java.lang.String getExpression() {
return expression;
}
public void setExpression(java.lang.String expression) {
this.expression = expression;
}
public com.jeecms.cms.entity.main.CmsSite getSite() {
return site;
}
public void setSite(com.jeecms.cms.entity.main.CmsSite site) {
this.site = site;
}
}
　　持久对象 CmsScheduler.java
　　package com.jeecms.cms.entity.assist;
import java.util.Date;
import com.jeecms.cms.entity.assist.base.BaseCmsScheduler;
/**
* 计划持久对象
* @author javacoo
* @since 2011-11-07
*/
public class CmsScheduler extends BaseCmsScheduler {
private static final long serialVersionUID = 1L;
/**
* 停止状态
*/
public static final int STOP = 0;
/**
* 采集状态
*/
public static final int START = 1;
/**
* 是否停止
*
* @return
*/
public boolean isStop() {
int status = getStatus();
return status == 0;
}
public void init() {
if (getStatus() == null) {
setStatus(STOP);
}
}
public CmsScheduler(){
super();
}
public CmsScheduler(java.lang.Integer id){
super(id);
}
public CmsScheduler(Integer id,String name, Date startTime, Date endTime,
Integer status, Integer associateId, String moduleType, String expression,com.jeecms.cms.entity.main.CmsSite site) {
super(id,name,startTime,endTime,status,associateId,moduleType,expression,site);
}
}
　　HBM 文件 CmsScheduler.hbm.xml
　　



false










　　===================================定时任务模块相关互助=========== ==== ========================
　　规划框架
　　规划框架-任务调度Scheduler.java
　　package com.jeecms.common.scheduling.core;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
* 计划框架-任务调度
*
* 用于提供必要的计划,Scheduler 的每一个实例都拥有 Timer 的一个实例，用于提供底层计划
* 它将一组单次定时器串接在一起，以便在由 ScheduleIterator 指定的各个时间执行 SchedulerTask 类
*
* @author javacoo
* @since 2011-11-02
*/
public class Scheduler {
/**Timer实例*/
private final Timer timer = new Timer();
/**
* 定时任务计划
* @author javacoo
* @since 2011-11-02
*/
class SchedulerTimerTask extends TimerTask {
private SchedulerTask schedulerTask;
private ScheduleIterator iterator;
public SchedulerTimerTask(SchedulerTask schedulerTask,
ScheduleIterator iterator) {
this.schedulerTask = schedulerTask;
this.iterator = iterator;
}
public void run() {
schedulerTask.run();
reschedule(schedulerTask, iterator);
}
}
public Scheduler() {
}
/**
* 取消执行
*/
public void cancel() {
timer.cancel();
}
/**
* 计划的入口点
*
* 通过调用 ScheduleIterator 接口的 next()，发现第一次执行 SchedulerTask 的时间。
* 然后通过调用底层 Timer 类的单次 schedule() 方法，启动计划在这一时刻执行。
* 为单次执行提供的 TimerTask 对象是嵌入的 SchedulerTimerTask 类的一个实例，
* 它包装了任务和迭代器（iterator）。在指定的时间，调用嵌入类的 run() 方法，
* 它使用包装的任务和迭代器引用以便重新计划任务的下一次执行
*
* @param schedulerTask SchedulerTimerTask 类的一个实例
* @param iterator ScheduleIterator 接口的一个实例
*/
public void schedule(SchedulerTask schedulerTask, ScheduleIterator iterator) {
Date time = iterator.next();
if (time == null) {
schedulerTask.cancel();
} else {
synchronized (schedulerTask.lock) {
if (schedulerTask.state != SchedulerTask.VIRGIN) {
throw new IllegalStateException("任务已经执行/取消");
}
schedulerTask.state = SchedulerTask.SCHEDULED;
schedulerTask.timerTask = new SchedulerTimerTask(schedulerTask,iterator);
timer.schedule(schedulerTask.timerTask, time);
}
}
}
/**
* 重新制定计划
* @param schedulerTask SchedulerTimerTask 类的一个实例
* @param iterator ScheduleIterator 接口的一个实例
*/
private void reschedule(SchedulerTask schedulerTask,
ScheduleIterator iterator) {
Date time = iterator.next();
if (time == null) {
schedulerTask.cancel();
} else {
synchronized (schedulerTask.lock) {
if (schedulerTask.state != SchedulerTask.CANCELLED) {
schedulerTask.timerTask = new SchedulerTimerTask(
schedulerTask, iterator);
timer.schedule(schedulerTask.timerTask, time);
}
}
}
}
}
　　规划框架——时间生成器接口ScheduleIterator.java
　　package com.jeecms.common.scheduling.core;
import java.util.Date;
/**
* 计划框架-时间生成器接口
* 将 SchedulerTask 的计划执行时间指定为一系列 java.util.Date 对象的接口
* 然后 next() 方法按时间先后顺序迭代 Date 对象,返回值 null 会使任务取消（即它再也不会运行）
* @author javacoo
* @since 2011-11-02
*/
public interface ScheduleIterator {
/**
* 返回下次计划执行时间
* @return 下次计划执行时间
*/
Date next();
}
　　定时任务抽象类SchedulerTask.java
　　package com.jeecms.common.scheduling.core;
import java.util.TimerTask;
/**
* 计划任务抽象类
*
* SchedulerTask 在其生命周期中要经历一系列的状态。创建后，它处于 VIRGIN 状态，
* 这表明它从没有计划过。计划以后，它就变为 SCHEDULED 状态，
* 再用下面描述的方法之一取消任务后，它就变为 CANCELLED 状态。
* 管理正确的状态转变 —— 如保证不对一个非 VIRGIN 状态的任务进行两次计划 ——
* 增加了 Scheduler 和 SchedulerTask 类的复杂性。在进行可能改变任务状态的操作时，
* 代码必须同步任务的锁对象
*
* @author javacoo
* @since 2011-11-02
*/
public abstract class SchedulerTask implements Runnable {
/**同步任务的锁对象*/
final Object lock = new Object();
/**状态*/
int state = VIRGIN;
/**初始状态*/
static final int VIRGIN = 0;
/**任务状态*/
static final int SCHEDULED = 1;
/**取消状态*/
static final int CANCELLED = 2;
/**TimerTask 对象*/
TimerTask timerTask;
protected SchedulerTask() {
}
/**执行的任务，由子类实现*/
public abstract void run();
/**取消任务
*
* 任务再也不会运行了，不过已经运行的任务仍会运行完成
*
*/
public boolean cancel() {
synchronized (lock) {
if (timerTask != null) {
timerTask.cancel();
}
boolean result = (state == SCHEDULED);
state = CANCELLED;
return result;
}
}
public long scheduledExecutionTime() {
synchronized (lock) {
return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
}
}
}
　　调度框架-时间生成器接口实现类SimpleScheduleIterator.java
　　package com.jeecms.common.scheduling.impl;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import com.jeecms.common.scheduling.core.ScheduleIterator;
/**
* 计划框架-时间生成器接口实现类
* 返回 月/周/天/小时/分钟/秒 计划的下一次执行时间
* 约定：参数以逗号分隔,*号表示无值
* 参数解释：
*
第一位：每个月的第几周</br>
*
第二位：每周的第几天</br>
*
第三位：天(几号)</br>
*
第四位：小时(24小时制)</br>
*
第五位：分钟</br>
*
第六位：秒</br>
*
* 参数样例：
*
1,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一个月执行一次,即下次执行时间是 下个月的第一周的第6天的15:20:30</br>
*
*,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一周执行一次,即下次执行时间是 下一周的第6天的15:20:30</br>
*
*,*,4,15,20,30 表示 从今天的15:20:30开始，每隔一天执行一次,即下次执行时间是 下一天的15:20:30</br>
*
*,*,*,15,20,30 表示 从今天的15:20:30开始，每隔一小时执行一次,即下次执行时间是 16:20:30</br>
*
*,*,*,*,20,30 表示 从这个小时的20:30开始，每隔一分钟执行一次,即下次执行时间是 *:21:30</br>
*
*,*,*,*,*,30 表示 从当前时间的30秒开始，每隔一秒执行一次,即下次执行时间是 *:*:31</br>
*
* @author javacoo
* @since 2011-11-03
*/
public class SimpleScheduleIterator implements ScheduleIterator {
private final ScheduleParamBean scheduleParamBean;
private final Calendar calendar = Calendar.getInstance();
private final Calendar orginCalendar = Calendar.getInstance();
public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean) {
this(scheduleParamBean, new Date());
}
public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean, Date date) {
this.scheduleParamBean = scheduleParamBean;
orginCalendar.setTime(date);
calendar.setTime(date);
if(null != scheduleParamBean.getWeekOfMonth()){
calendar.set(Calendar.WEEK_OF_MONTH, scheduleParamBean.getWeekOfMonth());
}
//如果设置了每周的第几天和一个月的第几天，则忽略一个月的第几天
if(null != scheduleParamBean.getDayOfWeek()){
calendar.set(Calendar.DAY_OF_WEEK, scheduleParamBean.getDayOfWeek());
}else if(null != scheduleParamBean.getDayOfMonth()){
calendar.set(Calendar.DAY_OF_MONTH, scheduleParamBean.getDayOfMonth());
}
if(null != scheduleParamBean.getHourOfDay()){
calendar.set(Calendar.HOUR_OF_DAY, scheduleParamBean.getHourOfDay());
}
if(null != scheduleParamBean.getMinute()){
calendar.set(Calendar.MINUTE, scheduleParamBean.getMinute());
}
if(null != scheduleParamBean.getSecond()){
calendar.set(Calendar.SECOND, scheduleParamBean.getSecond());
}
calendar.set(Calendar.MILLISECOND, 0);
//如果设置时间 大于当前时间
if (!calendar.getTime().before(date)) {
System.out.println(calendar.getTime() +"大于当前时间："+date);
if(null != scheduleParamBean.getWeekOfMonth()){
calendar.add(Calendar.MONTH, -1);
}else if(null != scheduleParamBean.getDayOfWeek()){
calendar.add(Calendar.DAY_OF_WEEK, -6);
}else if(null != scheduleParamBean.getDayOfMonth()){
calendar.add(Calendar.DAY_OF_MONTH, -1);
}else if(null != scheduleParamBean.getHourOfDay()){
calendar.add(Calendar.HOUR_OF_DAY, -1);
}else if(null != scheduleParamBean.getMinute()){
calendar.add(Calendar.MINUTE, -1);
}else if(null != scheduleParamBean.getSecond()){
calendar.add(Calendar.SECOND, -1);
}
}else{//如果小于，则会一下执行多次，所以在天,小时,分钟,秒 都加上相应时间差
System.out.println(calendar.getTime() +"小于当前时间："+date);
if(null != scheduleParamBean.getDayOfMonth()){
calendar.add(Calendar.DAY_OF_MONTH, orginCalendar.get(Calendar.DAY_OF_MONTH) - scheduleParamBean.getDayOfMonth());
}else if(null != scheduleParamBean.getHourOfDay()){
calendar.add(Calendar.HOUR_OF_DAY, orginCalendar.get(Calendar.HOUR_OF_DAY) - scheduleParamBean.getHourOfDay());
}else if(null != scheduleParamBean.getMinute()){
calendar.add(Calendar.MINUTE, orginCalendar.get(Calendar.MINUTE) - scheduleParamBean.getMinute());
}else if(null != scheduleParamBean.getSecond()){
calendar.add(Calendar.SECOND, orginCalendar.get(Calendar.SECOND) - scheduleParamBean.getSecond());
}
}
}
public Date next() {
if(null != scheduleParamBean.getWeekOfMonth()){
calendar.add(Calendar.MONTH, 1);
}else if(null != scheduleParamBean.getDayOfWeek()){
calendar.add(Calendar.DAY_OF_WEEK, 6);
}else if(null != scheduleParamBean.getDayOfMonth()){
calendar.add(Calendar.DAY_OF_MONTH, 1);
}else if(null != scheduleParamBean.getHourOfDay()){
calendar.add(Calendar.HOUR_OF_DAY, 1);
}else if(null != scheduleParamBean.getMinute()){
calendar.add(Calendar.MINUTE, 1);
}else if(null != scheduleParamBean.getSecond()){
calendar.add(Calendar.SECOND, 1);
}
System.out.println("下次执行时间:"+calendar.getTime());
return calendar.getTime();
}
}
　　调度参数beanScheduleParamBean.java
　　package com.jeecms.common.scheduling.impl;
/**
* 时间计划参数bean
* @author javacoo
* @since 2011-11-04
*/
public class ScheduleParamBean {
/**每个月的第几周,每周的第几天,每个月的第几天,小时(24小时制),分钟,秒*/
private Integer weekOfMonth,dayOfWeek,dayOfMonth,hourOfDay, minute, second;
public ScheduleParamBean(){
}
public ScheduleParamBean(Integer weekOfMonth, Integer dayOfWeek,
Integer dayOfMonth, Integer hourOfDay, Integer minute,
Integer second) {
super();
this.weekOfMonth = weekOfMonth;
this.dayOfWeek = dayOfWeek;
this.dayOfMonth = dayOfMonth;
this.hourOfDay = hourOfDay;
this.minute = minute;
this.second = second;
}
public Integer getWeekOfMonth() {
return weekOfMonth;
}
public void setWeekOfMonth(Integer weekOfMonth) {
this.weekOfMonth = weekOfMonth;
}
public Integer getDayOfWeek() {
return dayOfWeek;
}
public void setDayOfWeek(Integer dayOfWeek) {
this.dayOfWeek = dayOfWeek;
}
public Integer getDayOfMonth() {
return dayOfMonth;
}
public void setDayOfMonth(Integer dayOfMonth) {
this.dayOfMonth = dayOfMonth;
}
<p>
public Integer getHourOfDay() {
return hourOfDay;
}
public void setHourOfDay(Integer hourOfDay) {
this.hourOfDay = hourOfDay;
}
public Integer getMinute() {
return minute;
}
public void setMinute(Integer minute) {
this.minute = minute;
}
public Integer getSecond() {
return second;
}
public void setSecond(Integer second) {
this.second = second;
}
@Override
public String toString() {
return "ScheduleParamBean [dayOfMonth=" + dayOfMonth + ", dayOfWeek="
+ dayOfWeek + ", hourOfDay=" + hourOfDay + ", minute=" + minute
+ ", second=" + second + ", weekOfMonth=" + weekOfMonth + "]";
}
}</p>
　　采集相关
　　HTML解析工具类接口ParseHtmlTool.java
　　package com.jeecms.common.crawler.util;
import java.util.List;
import java.util.Map;
/**
* HTML解析工具类接口
* @author javacoo
* @since 2011-10-31
*/
public interface ParseHtmlTool {
/**
* 取得连接集合
* @param orginHtml 原始HTML
* @return 连接集合
*/
List getUrlList( String orginHtml);
/**
* 取得标题集合
* @param orginHtml 原始HTML
* @return 标题集合
*/
List getTitleList(String orginHtml);
/**
* 取得指定区域的HTML内容
* @return 指定区域的HTML内容
*/
String getHtml(String orginHtml);
/**
* 取得连接标题Map集合
* @param orginHtml 原始HTML
* @return 连接标题Map集合
*/
List getUrlAndTitleMap(String orginHtml);
}
　　HTML解析工具，HtmlParser实现类HtmlParserImpl.java
　　package com.jeecms.common.crawler.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.filters.HasAttributeFilter;
import org.htmlparser.filters.NodeClassFilter;
import org.htmlparser.filters.TagNameFilter;
import org.htmlparser.nodes.RemarkNode;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;
import com.jeecms.cms.entity.assist.CmsAcquisition;
import com.jeecms.common.crawler.ParamBean;
/**
* HTML解析工具,HtmlParser实现类
* @author javacoo
* @since 2011-10-31
*/
public class HtmlParserImpl implements ParseHtmlTool{
/**连接集合标志*/
private static String LINK_KEY = "linkKey";
/**标题集合标志*/
private static String TITLE_KEY = "titleKey";
/**单标签标志*/
private static String SINGLE_TAG = "singleTag";
/**连接正则表达式*/
private static String LINK_REGX = "(.*?)</a>";
/**正则表达式对象*/
private Pattern pt = Pattern.compile(LINK_REGX);
/**采集参数bean*/
private ParamBean paramBean;
public HtmlParserImpl(CmsAcquisition acqu){
parseRequestParam(acqu);
}
/**
* 取得标题集合
* @param orginHtml 原始HTML
* @return 标题集合
*/
public List getTitleList(String orginHtml) {
orginHtml = getHtmlByFilter(paramBean.getLinksetStartMap(), paramBean.getLinksetEndMap(),orginHtml);
if (StringUtils.isNotEmpty(orginHtml)) {
return getUrlOrTitleListByType(orginHtml,TITLE_KEY);
}
return null;
}
/**
* 取得连接集合
* @param orginHtml 原始HTML
* @return 连接集合
*/
public List getUrlList(String orginHtml) {
orginHtml = getHtmlByFilter(paramBean.getLinksetStartMap(), paramBean.getLinksetEndMap(),orginHtml);
if (StringUtils.isNotEmpty(orginHtml)) {
return getUrlOrTitleListByType(orginHtml,LINK_KEY);
}
return null;
}
/**
* 取得指定区域的HTML内容
* @param orginHtml 原始HTML
* @return 指定区域的HTML内容
* @throws ParserException
*/
public String getHtml(String orginHtml) {
orginHtml = getHtmlByFilter(paramBean.getContentStartMap(), paramBean.getContentEndMap(),orginHtml);
return orginHtml;
}
/**
* 取得连接标题Map
* @param orginHtml 原始HTML
* @return 连接标题Map
*/
public List getUrlAndTitleMap(String orginHtml){
return getUrlAandTitleMap(orginHtml);
}
/**
* 解析采集参数,并封装到ParamBean
* @param acqu 原始采集参数
* @return 采集参数封装bean
*/
private void parseRequestParam(CmsAcquisition acqu){
paramBean = new ParamBean();
if(!StringUtils.isEmpty(acqu.getLinksetStart())){
paramBean.setLinksetStartMap(populateParamMap(acqu.getLinksetStart()));
}
if(!StringUtils.isEmpty(acqu.getLinksetEnd())){
paramBean.setLinksetEndMap(populateParamMap(acqu.getLinksetEnd()));
}
if(!StringUtils.isEmpty(acqu.getContentStart())){
paramBean.setContentStartMap(populateParamMap(acqu.getContentStart()));
}
if(!StringUtils.isEmpty(acqu.getContentEnd())){
paramBean.setContentEndMap(populateParamMap(acqu.getContentEnd()));
}
}
/**
* 得到连接标题MAP
* @param html html内容
* @return 连接或者标题集合
*/
private List getUrlAandTitleMap(String html) {
html = getHtmlByFilter(paramBean.getLinksetStartMap(), paramBean.getLinksetEndMap(),html);
List resultMapList = new ArrayList();
Map resultMap = null;
Matcher m = pt.matcher(html);
while (m.find()) {
if(StringUtils.isNotEmpty(m.group(1)) && StringUtils.isNotEmpty(m.group(2))){
resultMap = new HashMap();
resultMap.put(LINK_KEY, m.group(1));
resultMap.put(TITLE_KEY, m.group(2));
resultMapList.add(resultMap);
}
}
return resultMapList;
}
/**
* 得到地址集
* @param html html内容
* @param type 1 ：取得连接集合，2：取得标题集合
* @return 连接或者标题集合
*/
private List getUrlOrTitleListByType(String html, String type) {
List resultList = new ArrayList();
Matcher m = pt.matcher(html);
String result = "";
int pos = 1;
if(TITLE_KEY.equals(type)){
pos = 2;
}
while (m.find()) {
result = m.group(pos);
resultList.add(result);
}
return resultList;
}
/**
* 取得指定区域的HTML内容
* @param tagMap 标签MAP
* @param removeTagMap 要过滤的标签MAP
* @param orginHtml 原始HTML
* @return 指定区域的HTML内容
* @throws ParserException
*/
private String getHtmlByFilter(Map tagMap,
Map removeTagMap, String orginHtml) {
try {
Parser parser = new Parser();
parser.setInputHTML(orginHtml);
// 第一步取得指定属性/标签内容
String tempKey = null;
String tempValue = null;
String[] tempValueArr = null;
StringBuilder sb = new StringBuilder();
NodeFilter filter = null;
for(Iterator it = tagMap.keySet().iterator(); it.hasNext();){
tempKey = it.next();
tempValue = tagMap.get(tempKey);
if(tempValue.contains("|")){
tempValueArr = tempValue.split("\\|");
}else{
tempValueArr = new String[]{tempValue};
}
for(String value : tempValueArr){
filter = populateFilter(tempKey,value);
appendHtmlByFilter(parser, filter, sb);
}
}
// 第二步过滤指定属性/标签内容
String contentHtml = sb.toString();
for (Iterator it = removeTagMap.keySet().iterator(); it
.hasNext();) {
tempKey = it.next();
tempValue = removeTagMap.get(tempKey);
if(tempValue.contains("|")){
tempValueArr = tempValue.split("\\|");
}else{
tempValueArr = new String[]{tempValue};
}
for(String value : tempValueArr){
filter = populateFilter(tempKey,value);
contentHtml = removeHtmlByFilter(parser, filter, contentHtml);
}
}
//第三步过滤注释
filter = new NodeClassFilter(RemarkNode.class);
contentHtml = removeHtmlByFilter(parser, filter, contentHtml);
System.out.println("=================================结果=======================================");
System.out.println(contentHtml);
return contentHtml;
} catch (ParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "";
}
/**
* 解析并组装采集参数，支持标签属性/值形式和标签名称形式，可混合使用
* 约定采集参数格式如下
* 1，标签属性/值形式，如：class=articleList|tips,id=fxwb|fxMSN|fxMSN
* 2，标签名称形式，如：div,p,span
* 3，混合形式，如：class=articleList|tips,id=fxwb|fxMSN|fxMSN,div,p,span
* @param paramStr 参数字符串
*/
private Map populateParamMap(String paramStr) {
Map paramMap = new HashMap();
String[] paramStrArr = paramStr.split(",");
String[] tempStrArr = null;
StringBuilder sb = new StringBuilder();
for(String temp : paramStrArr){
if(temp.contains("=")){
tempStrArr = temp.split("=");
paramMap.put(tempStrArr[0], tempStrArr[1]);
}else{
if(StringUtils.isNotEmpty(temp)){
sb.append(temp).append("|");
}
}
}
if(StringUtils.isNotEmpty(sb.toString())){
paramMap.put(SINGLE_TAG, sb.substring(0, sb.length() - 1));
}
return paramMap;
}
/**
* 组装过滤器
* @param key 键
* @param value 值
* @return 过滤器
*/
private NodeFilter populateFilter(String key,String value) {
NodeFilter filter;
if(SINGLE_TAG.equals(key)){
filter = new TagNameFilter(value);
}else{
filter = new HasAttributeFilter(key,value);
}
return filter;
}
/**
* 过滤指定属性标签HTML
* @param parser 解析器
* @param filter 属性过滤器
* @param orginHtml 原始HTML
* @return 过滤后HTML
* @throws ParserException
*/
private String removeHtmlByFilter(Parser parser, NodeFilter filter,String orginHtml) throws ParserException {
parser.setInputHTML(orginHtml);
NodeList nodes = parser.extractAllNodesThatMatch(filter);
for (int i = 0; i < nodes.size(); i++) {
Node textnode = (Node) nodes.elementAt(i);
orginHtml = StringUtils.remove(orginHtml, textnode.toHtml());
}
return orginHtml;
}
/**
* 取得所有指定属性/标签的HTML
* @param parser 解析器
* @param filter 过滤器
* @param sb
* @throws ParserException
*/
private void appendHtmlByFilter(Parser parser, NodeFilter filter,
StringBuilder sb) throws ParserException {
NodeList nodes = parser.extractAllNodesThatMatch(filter);
for (int i = 0; i < nodes.size(); i++) {
Node textnode = (Node) nodes.elementAt(i);
sb.append(textnode.toHtml());
}
}
/**
* 解析并组装采集参数，支持标签属性/值形式和标签名称形式，可混合使用
* 约定采集参数格式如下
* 1，标签属性/值形式，如：class=articleList|tips,id=fxwb|fxMSN|fxMSN
* 2，标签名称形式，如：div,p,span
* 3，混合形式，如：class=articleList|tips,id=fxwb|fxMSN|fxMSN,div,p,span
* @param paramMap 参数map
* @param str 参数字符串
*/
private void populateParamMap(Map paramMap,String paramStr) {
String[] paramStrArr = paramStr.split(",");
String[] tempStrArr = null;
StringBuilder sb = new StringBuilder();
for(String temp : paramStrArr){
if(temp.contains("=")){
tempStrArr = temp.split("=");
paramMap.put(tempStrArr[0], tempStrArr[1]);
}else{
if(StringUtils.isNotEmpty(temp)){
sb.append(temp).append("|");
}
}
}
if(StringUtils.isNotEmpty(sb.toString())){
paramMap.put(SINGLE_TAG, sb.substring(0, sb.length() - 1));
}
}
/**
* 测试方法-打开文件并返回内容
* @param szFileName 文件绝对地址
* @param charset 字符集
* @return 内容
*/
public static String openFile(String szFileName,String charset) {
try {
BufferedReader bis = new BufferedReader(new InputStreamReader(
new FileInputStream(new File(szFileName)), charset));
StringBuilder szContent = new StringBuilder();
String szTemp;
while ((szTemp = bis.readLine()) != null) {
szContent.append(szTemp).append("\n");
}
bis.close();
return szContent.toString();
} catch (Exception e) {
return "";
}
}
/**
* 测试取得连接地址和标题
* @throws ParserException
*/
public void testFetchLinkAndTitle() throws ParserException{
String html = openFile("F:\\4.htm","UTF-8");
String result = "";
Map map = new HashMap();
map.put("class", "m_list");
Map notMap = new HashMap();
//notMap.put("class", "atc_ic_f");
result = getHtmlByFilter(map,notMap,html);
System.out.println("=============================result============================");
System.out.println(result);
System.out.println("==========================================================");
Pattern pt = Pattern.compile("(.*?)</a>");
Matcher m = pt.matcher(result);
String link = null;
String title = null;
while (m.find()) {
link = m.group(1);
title = m.group(2);
if (StringUtils.isNotEmpty(link)) {
System.out.println("url : " + link);
System.out.println("title : " + title);
}
}
}
/**
* 测试取得内容
* @throws ParserException
*/
public void testFetchContent() throws ParserException{
String html = openFile("F:\\6.shtml","GB2312");
Map map = new HashMap();
map.put("id", "artibody");
Map notMap = new HashMap();
notMap.put(SINGLE_TAG, "style|script");
notMap.put("type", "text/javascript");
notMap.put("class", "icon_fx|blkComment otherContent_01");
notMap.put("style", "text-align: right;padding-right:10px;|margin-top:6px;|font-size: 12px ! important;|font-size:12px");
notMap.put("id", "fxwb|fxMSN|fxMSN|comment_t_show_top");
getHtmlByFilter(map,notMap,html);
}
/**
* 测试解析参数
*/
public void testParseParam(){
Map map = new HashMap();
populateParamMap(map,"class=articleList|tips,p,div");
String tempKey = null;
String tempValue = null;
String[] tempValueArr = null;
for (Iterator it = map.keySet().iterator(); it.hasNext();) {
tempKey = it.next();
tempValue = map.get(tempKey);
if(tempValue.contains("|")){
tempValueArr = tempValue.split("\\|");
}else{
tempValueArr = new String[]{tempValue};
}
for(String value : tempValueArr){
System.out.println("tempKey:" + tempKey);
System.out.println("value:" + value);
}
}
}
/**
* 测试过滤标签
* @throws ParserException
*/
public void testRemarkFilter() throws ParserException{
String html = openFile("F:\\6.shtml","GB2312");
System.out.println("=========================过滤注释前HTML==================================");
System.out.println(html);
NodeFilter filter = new NodeClassFilter(RemarkNode.class);
html = removeHtmlByFilter(new Parser(), filter, html);
System.out.println("=========================过滤注释后HTML==================================");
System.out.println(html);
}
public static void main(String[] args) throws ParserException,
URISyntaxException, IOException {
HtmlParserImpl parseHtmlTool = new HtmlParserImpl(new CmsAcquisition());
//parseHtmlTool.testParseParam();
//parseHtmlTool.testFetchLinkAndTitle();
//parseHtmlTool.testFetchContent();
//parseHtmlTool.testRemarkFilter();
}
}
　　采集参数封装beanParamBean.java
　　package com.jeecms.common.crawler;
import java.util.HashMap;
import java.util.Map;
/**
* 采集参数封装bean
* @author javacoo
* @since 2011-10-31
*/
public class ParamBean {
/**待采集连接区域属性MAP*/
private Map linksetStartMap = new HashMap();
/**待采集连接区域过滤属性MAP*/
private Map linksetEndMap = new HashMap();
/**待采集内容区域属性MAP*/
private Map contentStartMap = new HashMap();
/**待采集内容区域过滤属性MAP*/
private Map contentEndMap = new HashMap();
public Map getLinksetStartMap() {
return linksetStartMap;
}
public void setLinksetStartMap(Map linksetStartMap) {
this.linksetStartMap = linksetStartMap;
}
public Map ge 查看全部

　　最新版:文章自动采集器电脑版 3.5.5
　　标签：熟食数据data采集
　　文章Automatic采集器PC版是一款功能强大的文章一键式网页扫描提取软件。文章Automatic采集器 PC客户端软件可以比较分析各种大型门户网站网站和大型搜索引擎分析其内容效果，并根据文章内容进行扫描和提取超文本协议的结构特征。使用起来高效方便，无广告，不管是什么网站 文章都可以高产采集。
　　文章自动采集器 PC 客户端软件功能
　　1.百度新闻和网页。搜狗新闻和网页。360 新闻和网页。谷歌新闻和网页。必备的新闻和网页。雅虎；批量关键词 自动采集。
　　2、指定网站列列表下的所有文章都可以有针对性的采集，无需编写复杂的规则即可智能匹配。
　　3、文章的翻译功能，可以将喜欢的文章翻译成英文，再翻译成中文，从而实现伪原创文章的翻译，支持谷歌和有道翻译。
　　4、自动提取任意网页文字，准确率95%以上，依靠水秒软件独有的通用文字识别智能算法。
　　
　　文章自动采集器 PC客户端功能介绍
　　1、采集分页：如果文本有分页显示，会自动采集合并分页。
　　2、删除链接：删除网页中锚文本的链接功能，只留下锚文本的标题。
　　3.txt格式：保存为txt文本（自动清除HTML标签）。
　　4、调试模式：在正文开头插入“调试模式：标题和链接”的内容，方便进入原网页，对比文字识别效果。
　　5. 标题中的关键词：仅采集 标题中收录搜索关键词 的页面。
　　6、放弃短标题：当自动识别的标题长度小于原标题的三分之一时，为短标题。通常这种题名是错误的，可以勾选舍弃，这样就变成原来的题名了（这个Duan见了就明白了）。
　　7、删除外码：在使用自动识别和精准标签时，通常会收录div标签等外码。如果你不需要它，你必须勾选它以删除它。
　　
　　文章自动采集器PC 客户端软件更新
　　修复关键词采集收录:等符号，没有转换，保存失败的问题
　　异常退出后添加关键词采集，下次启动采集恢复进度
　　其他图标更新。
　　修复[列表页采集.Address.Generate]生成列表页时缺少最后一页的问题
　　优化采集文章的跳出逻辑
　　当百家账号采集时，会自动弹出验证
　　新增标题识别和文本识别JSON路径值高级解码功能
　　最新版:有哪些伪原创软件_消重去重伪原创软件下载
　　质量答案回答者：帆
　　最佳答案： 智能媒体AI伪原创可以，免费也可以批量，文章质量相当不错，通过伪原创工具生成文章，会更好的收录并被搜索引擎索引，下面就给大家介绍几款免费伪原创软件，有需要的朋友可以看看。1.牛奶托盘SEO伪原创：牛奶托盘SEO伪原创工具，是一种SEO实用工具。
　　-----------------------------------------------------------------
　　回答者：朱跃爱
　　
　　什么是最好的伪原创软件？什么是免费的伪原创软件？如果需求不大，可以试试智能媒体AI批量写作助手，前几天刚下载的智能伪原创软件，不错！常用的免费SEO伪原创工具有哪些？ 1 做SEO的人需要使用伪原创工具，伪原创工具都是SEEER实用程序，平时没有时间写原创文章，需要通过伪原创文章工具文章伪原创在网上查找。
　　扩展信息：
　　1. 下载伪原创重复数据删除和重复数据删除软件
　　2. 文本伪原创工具
　　
　　3. 图像伪原创工具
　　4. 伪原创视频软件APP的
　　5. 伪原创工具移动应用程序
　　在线可用的伪原创软件有哪些？相信很多朋友都想知道哪些更可靠，更易于使用，对吧？小编为大家整理了免费的伪原创软件，各种原创软件应有尽有，赶快去了解吧！ 2018/5/8 18：47：36更多低级伪原创工具还处于同义词替换阶段，写猫等AI伪原创工具已经可以实现句子结构。
　　参考链接： 查看全部

　　分享文章:LY_定时发布文章、自动发布文章，定时发布的同时自动推送提交收录
　　每天都会自动释放。设置定时任务保存后，会开始运行完整的后台定时任务。当关闭任务保存时，定时器任务将停止。草稿文章或审稿文章可自动发布，或仅针对指定用户ID的草稿或审稿文章发布文章，文章ID会自动释放。
　　定期发布组可以设置五个不同的时间段，
　　参数设置方法为：开始时间-结束时间-释放数量，
　　比如8-10-5设置是每天8:00-10:00（含8:00和10:00）定时发布5篇文章，
　　发布组的时间格式从前到后设置为24小时格式。
　　
　　发布时间每天自动平均计算，每日文章发布时间不重叠。
　　支持：LY-link推送插件定时发布自动推送提交收录
　　下载插件：
　　LY_Regular release文章 - Z-Blog应用中心
　　
　　，新人注册时将获得5元现金。现在加入“有站计划”，赚取额外收入。
　　，买云服务器送机，最多免费3个月。
　　,2核2G4M低至50元/年，把握上云良机！
　　，全球首选云服务器，助力企业轻松出海。
　　，汇集阿里云近百款爆款产品，云端省钱，灵活计算新人聚集地。
　　分享的内容:spider抓取篇：百度不收录原因分析分享！
　　目前，百度蜘蛛抓取新链接有两种方式。一是主动查找抓取，二是从百度站长平台的链接提交工具获取数据。其中，通过主动推送功能“接收”的数据在百度中最为流行。欢迎来到蜘蛛。对于站长来说，如果链接很久没有收录，建议尝试使用主动推送功能，尤其是新的网站，主动推送首页数据，就是利于内部页面数据的爬取。
　　那么同学们要问了，为什么我提交数据后在线还是看不到显示呢？涉及的因素很多。在蜘蛛爬取的链接中，影响在线显示的因素有：
　　
　　1. 网站 被禁止。别笑，真有同学封杀百度蜘蛛，把数据交给百度，当然不能收录。
　　2.质量筛选。百度蜘蛛进入3.0后，对低质量内容的识别上了一个新台阶，尤其是时效性内容。从抓取阶段开始，进行质量评估和筛选，过滤掉大量过度优化的页面。从内部定期数据评估来看，低质量网页较之前减少了62%。
　　3. 爬取失败。爬取失败的原因有很多。有时候在办公​​室访问没问题，百度蜘蛛就遇到麻烦了。本站时刻注意保证网站在不同时间和地点的稳定性。
　　
　　4. 名额限制。虽然我们正在逐步放开主动推送的抓取限额，但是如果站内页面数量突然爆发式增长，还是会影响抓取优质链接收录，所以站内要注意收录 除了保证访问稳定网站安全，防止黑客注入。
　　以上就是百度为什么没有收录的分析，现在你明白了吗？希望它能帮助我们！
　　——想知道蜘蛛爬行：百度不收录原因分析分享！还有更多seo优化教程234IT 查看全部

　　解决方案:苹果cms主动推送php,苹果cms利用定时任务生成静态执行操作
　　Apple cms计划任务目前有两个内置操作采集计划资源和静态操作的计划生成
　　1. 定期执行资源库的文件采集：选择采集资源库
　　采集附加参数：可以从联盟资源库、自定义资源列表（在今日采集，采集本周，采集全部右键复制链接）获取参数部分。
　　例如：任务名称：cj_day任务描述：采集当天数据的其他参数：ac=cjall&h=24&xt=1&ct=&cjflag=b9c546ba925d22ed654927b44638df34&cjurl=
　　2. 定期生成静态执行文件： 选择生成其他参数：
　　例如：生成主页 ac=index 生成地图页面 ac=map 生成 rss ac=rss 生成百度站点地图=rss&ac2=
　　百度生成谷歌网站地图=rss&ac2=谷歌
　　生成主题主页 ac=
　　
　　topic_index生成主题详细信息页面 ac=topic_info&topic=1，2，3，4生成视频分类页面 ac=type&tab=
　　vod&vodtype=1，2使用当天的更新数据生成视频分类 ac=type&tab=vod&ac2=day 生成文章类别页面 ac=type&tab=art&
　　arttype=3，4使用当天的更新数据生成文章分类 ac=type&tab=art&ac2=day
　　生成自定义页面 ac=label&label=rand.html
　　生成视频详细信息页面 ac=info&tab=vod&
　　ids=1，2，3生成未生成的视频详细信息页面 ac=info&tab=vod&ac2=nomake
　　生成文章详细信息页面 ac=info&tab=art&
　　ids=1，2，3生成未生成的文章详细信息页面 ac=info&tab=art&ac2=nomake
　　3. 采集规则执行文件：选择采集规则CJ
　　
　　参数 id=1，即当前自定义采集规则采集的编号。
　　为了不影响服务器性能，当前仅采集第一页。
　　4.清理缓存执行文件：选择清理无参数缓存
　　5. 网址推送执行文件：选择网址推送网址发送
　　附加参数：百度主动推送当天视频ac=baidu_push&ac2=今天&mid=1百度主动推送当天文章ac=baidu_push&ac2=今天&mid=2百度主动推送当天特色ac=baidu_push&ac2=今天&mid=
　　3百度当天主动推演员 ac=baidu_push&ac2=今天&mid= 8百度主动推当天角色 ac=baidu_push&ac2=今天&mid=9
　　当天百度熊掌推送视频 AC=baidu_bear&AC2=今天&类型=实时&MID=1百度熊掌当天推送文章 AC=baidu_bear&AC2=今天&类型=实时MID=2百度熊掌推送日功能 AC=baidu_bear&AC2=今天&类型=实时&MID=3百度熊掌推送当天 AC=baidu_bear&AC2=今天&类型=实时&MID=
　　8百度熊掌推送当天字符AC=baidu_bear&AC2=今天&类型=实时&MID=9
　　最新版本:织梦DEDECMS任意文件上传漏洞与注入漏洞修复方法
　　针对漏洞织梦cms最新修复
　　同心 588 读 648 转 10
　　dedecmsCookie泄漏导致SQL漏洞修复
　　读命记 45
　　Dedecms最新的注入漏洞分析和修复方法
　　表演和青年阅读 502 转 5
　　Dede GetWebShell 0Day 漏洞分析报告
　　CCCCSHQ 阅读 351 转 3
　　DEDEcms数据库执行原理和cms代码层SQL注入防御思想
　　YLIU277 阅读 163
　　DEDE 列表，内页全站伪静态，DEDEcms httpd.ini伪静态
　　_▄经过小屋。阅读 2507 分机 65
　　在 Linux 系统上，应用了 Dedecms站点安全策略
　　树蚂蚁树 阅读 79
　　织梦安全吗？织梦 dedecms实现安全性的四个步骤
　　有你更好的DOC阅读1715转4
　　
　　dedecms、php168 木马 UDP 攻击的简单解决方案
　　展示与青春阅读 363
　　织梦 Dedecms优化安全设置指南
　　旅行乘客阅读 92
　　Dede自动采集伪原创发布更新的多合一插件
　　MSNBA 读 3082 分机 19
　　Dedecms的 TAG 标签生成一个静态 html 插件
　　猴子酷读2617转4德
　　德标签静态化方法
　　AutoCAD 学习阅读 1115 转 2
　　Dedecms模板标签系统选项 cfg
　　YLIU277 阅读 102
　　DEDEcms （织梦 程序） 5.5-5.7 Kill GetShell 漏洞
　　欧阳789987 read 12816 ext. 172
　　Linux 主机如何实现 dedecms 标记静态化
　　顾玉思藏书库读330转8
　　织梦（dedecms）仿现场教程第6讲-总头（2）杆件着陆箱（上）。
　　
　　MSNBA 读 817 到 24
　　!!!!! dedecms（织梦系统）常见问题解决方法集合
　　MSNBA 读取 627 比 8
　　DEDE：页脚调用解决全站调用页脚的新方法
　　显示和青年阅读 1759 转 6
　　如何设置 dedecms5.7 伪静态？Dede 5.7伪静态设置方法七步
　　表演和青年阅读 550 转 5
　　干货共享：Dedecms网站移动性有多少步？五步！
　　老虎别追我，读61转3德
　　德cms二次开发总结
　　YLIU277 阅读 757 转 3
　　Windows Server 2012 设置了一个 PHP+MySQL 环境来安装 Dedecms 系统
　　何鹏夫妇 - 图书馆阅读 273 转 2
　　Dedecms 4.0RC1 集成 phpwind 5.3 完成演练
　　桃花心木来读 81
　　织梦 dedecms media_add.php 上传漏洞解决方法
　　生活正义 读 71 转 2 查看全部