1、数据库用表：
CREATE TABLE `t_arctype` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`typeName` varchar(50) DEFAULT NULL,
`sortNo` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into `t_arctype` (`id`, `typeName`, `sortNo`) values('0','暂无分类','4');
insert into `t_arctype` (`id`, `typeName`, `sortNo`) values('1','java技术','1');
insert into `t_arctype` (`id`, `typeName`, `sortNo`) values('2','网页技术','2');
insert into `t_arctype` (`id`, `typeName`, `sortNo`) values('4','数据库技术','3');
CREATE TABLE `t_article` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`title` varchar(200) DEFAULT NULL,
`content` longtext,
`summary` varchar(400) DEFAULT NULL,
`crawlerDate` datetime DEFAULT NULL,
`clickHit` int(11) DEFAULT NULL,
`typeId` int(11) DEFAULT NULL,
`tags` varchar(200) DEFAULT NULL,
`orUrl` varchar(1000) DEFAULT NULL,
`state` int(11) DEFAULT NULL,
`releaseDate` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `typeId` (`typeId`),
CONSTRAINT `t_article_ibfk_1` FOREIGN KEY (`typeId`) REFERENCES `t_arctype` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2、所需依赖包：
<!-- jdbc驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.44</version>
</dependency>
<!-- 添加Httpclient支持 -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.2</version>
</dependency>
<!-- 添加jsoup支持 -->
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.10.1</version>
</dependency>
<!-- 添加日志支持 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
<!-- 添加ehcache支持 -->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.3</version>
</dependency>
<!-- 添加commons io支持 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.5</version>
</dependency>
3、所需工作包：
3-1：DateUtil 类
package com.zking.util;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 日期工具类
* @author user
*
*/
public class DateUtil {
/**
* 获取当前年月日路径
* @return
* @throws Exception
*/
public static String getCurrentDatePath()throws Exception{
Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
return sdf.format(date);
}
public static void main(String[] args) {
try {
System.out.println(getCurrentDatePath());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3-2：DbUtil 类
package com.zking.util;
import java.sql.Connection;
import java.sql.DriverManager;
/**
* 数据库工具类
* @author user
*
*/
public class DbUtil {
/**
* 获取连接
* @return
* @throws Exception
*/
public Connection getCon()throws Exception{
Class.forName(PropertiesUtil.getValue("jdbcName"));
Connection con=DriverManager.getConnection(PropertiesUtil.getValue("dbUrl"), PropertiesUtil.getValue("dbUserName"), PropertiesUtil.getValue("dbPassword"));
return con;
}
/**
* 关闭连接
* @param con
* @throws Exception
*/
public void closeCon(Connection con)throws Exception{
if(con!=null){
con.close();
}
}
public static void main(String[] args) {
DbUtil dbUtil=new DbUtil();
try {
dbUtil.getCon();
System.out.println("数据库连接成功");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("数据库连接失败");
}
}
}
3-3：PropertiesUtil 类
package com.zking.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* properties工具类
* @author user
*
*/
public class PropertiesUtil {
/**
* 根据key获取value值
* @param key
* @return
*/
public static String getValue(String key){
Properties prop=new Properties();
InputStream in=new PropertiesUtil().getClass().getResourceAsStream("/crawler.properties");
try {
prop.load(in);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return prop.getProperty(key);
}
}
3-4：crawler.properties
注:ehcacheXmlPath :为本地ehcache.xml 文件路径，二级缓存
blogImages：本地图片化路径
dbUrl=jdbc:mysql://localhost:3306/blog?autoReconnect=true
dbUserName=root
dbPassword=123
jdbcName=com.mysql.jdbc.Driver
ehcacheXmlPath=D://myDome/ehcache.xml
blogImages=D://myDome/blogImages/
3-5：log4j.properties
log4j.rootLogger=INFO, stdout,D
#Console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
#D
log4j.appender.D = org.apache.log4j.RollingFileAppender
log4j.appender.D.File = D://myDome/bloglogs/log.log
log4j.appender.D.MaxFileSize=100KB
log4j.appender.D.MaxBackupIndex=100
log4j.appender.D.Append = true
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
4、本地路径：
5、主要源码：
5-1：通用源码：
注意：主要代码开始--------------------以下是属于一个Demo中：
/**
* 记录当前日志
*/
private static Logger logger = Logger.getLogger(BlogCrawlerStarter.class);
/**
* 解析csdn博客最新文章首页地址
*/
private static String HomeURL = "https://www.csdn.net/nav/newarticles";
private static CloseableHttpClient httpClient;
//数据库连接
private static Connection con;
//缓存管理类
private static CacheManager cacheManager;
//缓存的槽
private static Cache cache;
5-2： 解析首页，获取网站里面所有内容(httpClient)
/**
* 解析首页，获取网站里面所有内容(httpClient)
*/
public static void parseHomePage() {
logger.info("开始爬取首页："+HomeURL);
//缓存初始化
//根据配置创建
cacheManager = CacheManager.create(PropertiesUtil.getValue("ehcacheXmlPath"));
cache = cacheManager.getCache("cnblog");
httpClient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(HomeURL);
//设置爬虫时间 连接操作时间 5秒，等待时间8秒
RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(8000).build();
httpGet.setConfig(config);
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//如果response为空
if(response == null) {
logger.info(HomeURL+":爬取无响应");
return;
}
//response有网站内容
//判断是否相应正常，如果正常则获取
if(response.getStatusLine().getStatusCode() ==200) {
//网络实体
HttpEntity entity = response.getEntity();
//获取首页内容
String homePageContext = EntityUtils.toString(entity,"utf-8");
//解析首页内容：
parseHomePageContent(homePageContext);
}
} catch (ClientProtocolException e) {
//把异常写入日志里面去
logger.error(HomeURL+"``ClientProtocolException",e);
} catch (IOException e) {
logger.error(HomeURL+"``IOException",e);
}finally {
try {//关闭响应
if(response != null) {//如果不为空
//关闭response
response.close();
}
if(httpClient != null) {//如果不为空
//关闭httpClient
httpClient.close();
}
} catch (IOException e) {
logger.error(HomeURL+"``IOException",e);
}
}
//如果是开启状态，就刷新
if(cache.getStatus() == Status.STATUS_ALIVE) {
cache.flush();
}
//关闭槽
cacheManager.shutdown();
logger.info("结束爬取首页："+HomeURL);
}
5-3：通过网络爬虫框架jsoup,解析网页内容。获取想要的数据（博客的链接）
/**
* 通过网络爬虫框架jsoup,解析网页内容。获取想要的数据（博客的链接）
* @param homePageContext
*/
private static void parseHomePageContent(String homePageContext) {
//通过jQuery选择器进行选取
Document doc = Jsoup.parse(homePageContext);
//从最低层往上找 :获取链接
Elements aEles = doc.select("#feedlist_id .list_con .title h2 a");
//遍历：找到最新的博客链接
for (Element aEle : aEles) {
String blogUrl = aEle.attr("href");
//如果地址为空
if(null == blogUrl || "".equals(blogUrl)) {
logger.info("该博客无内容，不再爬取插入数据库");
continue;//结束爬取
}
//如果数据库已经存在该数据
if(cache.get(blogUrl) != null) {
logger.info("该数据已经被爬取到数据库中，不再爬取插入数据库");
continue;//结束爬取
}
parseBlogUrl(blogUrl);
}
}
5-4：通过博客地址获取博客的标题，以及博客的内容
/**
* 通过博客地址获取博客的标题，以及博客的内容
* @param blogUrl
*/
private static void parseBlogUrl(String blogUrl) {
logger.info("开始爬取博客网页："+blogUrl);
httpClient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(blogUrl);
//设置爬虫时间 连接操作时间 5秒，等待时间8秒
RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(8000).build();
httpGet.setConfig(config);
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//如果response为空
if(response == null) {
logger.info(blogUrl+":爬取无响应");
return;
}
//response有网站内容
//判断是否相应正常，如果正常则获取
if(response.getStatusLine().getStatusCode() ==200) {
//网络实体
HttpEntity entity = response.getEntity();
//获取博客内容
String blogPageContent = EntityUtils.toString(entity,"utf-8");
//解析博客内容
parseBlogContent(blogPageContent,blogUrl);
}
} catch (ClientProtocolException e) {
//把异常写入日志里面去
logger.error(blogUrl+"``ClientProtocolException",e);
} catch (IOException e) {
logger.error(blogUrl+"``IOException",e);
}finally {
try {//关闭响应
if(response != null) {//如果不为空
//关闭response
response.close();
}
} catch (IOException e) {
logger.error(blogUrl+"``IOException",e);
}
}
logger.info("结束爬取博客网页："+blogUrl);
}
5-5：解析博客内容，获取博客中 的标题，以及所有内容，包含图片
/**
* 解析博客内容，获取博客中 的标题，以及所有内容
* @param blogPageContext
*/
private static void parseBlogContent(String blogContext,String linkUrl) {
Document doc = Jsoup.parse(blogContext);
//获取博客标题
Elements titleEles = doc.select("#mainBox main .article-header-box .article-header .article-title-box h1");
//如果标题为空，则不插入数据库
if(titleEles.size() == 0) {
logger.info("博客标题为空：不插入数据库！");
return;
}
String title = titleEles.get(0).html();
//获取对应的博客内容
Elements blogcontentEles = doc.select("#content_views");
if(blogcontentEles.size() == 0) {
logger.info("博客内容为空：不插入数据库！");
return;
}
String blogcontentdBody = blogcontentEles.get(0).html();
//获取对应的博客图片
Elements imgEles = doc.select("img");
//把图片放list
List<String> imgUrlList = new LinkedList<String>();
if(imgEles.size() > 0) {
for (Element imgEle : imgEles) {
imgUrlList.add(imgEle.attr("src"));
}
}
if(imgUrlList.size() > 0) {
//图片本地化
Map<String, String> replaceUrlMap= downloadImgList(imgUrlList);
blogContext = replaceContent(blogContext,replaceUrlMap);
}
//插入数据库
String sql = "insert into t_article values(null,?,?,null,now(),0,0,null,?,0,null)";
//初始化
try {
//预定义对象
PreparedStatement pst = con.prepareStatement(sql);
pst.setObject(1, title);
pst.setObject(2,blogcontentdBody);
pst.setObject(3, linkUrl);
if(pst.executeUpdate() == 0) {
logger.info("爬取博客信息插入数据库失败");
}else {
cache.put(new net.sf.ehcache.Element(linkUrl, linkUrl));
logger.info("爬取博客信息插入数据库成功");
}
} catch (SQLException e) {
logger.info("数据库异常--SQLException",e);
}
}
5-6：将别人的博客内容进行加工，将原有的图片地址换成本地的图片地址
/**
* 将别人的博客内容进行加工，将原有的图片地址换成本地的图片地址
* @param blogContext
* @param replaceUrlMap
* @return
*/
private static String replaceContent(String blogContext, Map<String, String> replaceUrlMap) {
for(Map.Entry<String, String> entry: replaceUrlMap.entrySet()) {
blogContext =blogContext.replace(entry.getKey(), entry.getValue());
}
return null;
}
5-7：别人服务器本地化
/**
* 别人服务器本地化
* @param imgUrlList
* @return
*/
private static Map<String, String> downloadImgList(List<String> imgUrlList) {
Map<String, String> replaceMap = new HashMap<String, String>();
for (String imgUrl : imgUrlList) {
CloseableHttpClient httpClient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(imgUrl);
//设置爬虫时间 连接操作时间 5秒，等待时间8秒
RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(8000).build();
httpGet.setConfig(config);
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
//如果response为空
if(response == null) {
logger.info(imgUrl+":爬取无响应");
}else {
//response有网站内容
//判断是否相应正常，如果正常则获取
if(response.getStatusLine().getStatusCode() ==200) {
//网络实体
HttpEntity entity = response.getEntity();
//图片存放地址
String blogImagesPath = PropertiesUtil.getValue("blogImages");
//按日期存放文件夹
String dateDir = DateUtil.getCurrentDatePath();
//生成的图片不能重复
String uuid = UUID.randomUUID().toString();
//图片后缀
String subfix= entity.getContentType().getValue().split("/")[1];
//文件名
String fileName = blogImagesPath + dateDir +"/"+uuid+"."+subfix;
//文件流
FileUtils.copyToFile(entity.getContent(), new File(fileName));
replaceMap.put(imgUrl, fileName);
}
}
} catch (ClientProtocolException e) {
//把异常写入日志里面去
logger.error(imgUrl+"``ClientProtocolException",e);
} catch (Exception e) {
logger.error(imgUrl+"``IOException",e);
}finally {
try {//关闭响应
if(response != null) {//如果不为空
//关闭response
response.close();
}
} catch (IOException e) {
logger.error(imgUrl+"``IOException",e);
}
}
}
return replaceMap;
}
5-8：初始化工具包
//初始化工具包
public static void start() {
//循环
while(true) {
DbUtil dbUtil = new DbUtil();
//获取连接
try {
con = dbUtil.getCon();
parseHomePage();
} catch (Exception e) {
logger.error("数据库连接失败");
}finally {
try {
if(con != null) {//关闭连接
con.close();
}
} catch (SQLException e) {
logger.info("关闭异常--SQLException",e);
}
}
//设置爬取时间
try {
//每隔半分钟爬取一次
Thread.sleep(1000*60/2);
} catch (InterruptedException e) {
logger.info("主线程休眠--InterruptedException",e);
}
}
}
5-9：运行：
public static void main(String[] args) {
start();
}
注意：主要代码结束-------------------
6、运行结果：
数据库插入数据：
本地化图片：
7：需要的二级缓存文件：ehcache.xml，需要的直接copy出去使用：
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--
磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
path:指定在硬盘上存储对象的路径
-->
<diskStore path="C:\blogCrawler\blogehcache" />
<!--
defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
eternal:代表对象是否永不过期
overflowToDisk:当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
-->
<defaultCache
maxElementsInMemory="1"
eternal="true"
overflowToDisk="true"/>
<cache
name="cnblog"
maxElementsInMemory="1"
diskPersistent="true"
eternal="true"
overflowToDisk="true"/>
</ehcache>
扫一扫
690
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
