1.引言

1.1 编写目的

1.2 项目背景

1.2 项目概要

2. 总体要求

2.1 系统功能概述

2.2 系统功能要求

3. 软件开发

3.1 软件需求分析

3.2 软件的概要设计

3.2.1 软件概要设计说明

3.2.3 基本设计概念和处理流程

3.3 软件的详细设计

3.3.1 系统结构

3.3.2 模块设计说明

3.3.3 爬虫模块

3.3.4 日志模块

3.3.5 数据处理

3.3.6 数据建模

3.3.7 事件画像

3.3.8 可视化展示

3.4 数据库设计

3.4.1 数据库说明

3.4.2 数据库操作

3.4.3 数据库结构

3.4.4 表结构

1.引言

1.1 编写目的

项目名称：基于互联网大数据的事件智能抓取和画像系统
项目成员：禹精华、刘可可、刘贤辉

对基于互联网大数据的事件智能抓取和画像系统进行算法描述和软件设计说明。

1.2 项目背景

项目背景：随着互联网大数据的发展，各种大数据的分析对各行业都产生了不同程度的影响。网站数据、社交媒体数据等是互联网大数据的重要组成部分。对于民航业领域，社会事件的发生，会很大程度影响旅客的出行需求变化，从而影响航空公司飞机运力投放、航班编排、票价策略调整等，对互联网事件的准确抓取和分析能够帮助航空公司更好的服务市场、服务旅客、提升收益。

行业背景：对于航空公司来说，能否预先判断旅客的出行需求，可用于航空公司及行业管理部门决定行业运力投放的合理性，从而提高旅客服务水平、提高航空公司航班收益水平，从互联网中获取大量的影响民航领域的信息能够帮助航空公司制定销售策略。

1.3 项目概要

开发团队：武汉职业技术学院筑梦云工作室demo01团队

项目开发平台说明：

操作系统：Windows7 及以上版本

应用服务器：Ubuntu Server 14.04 LTS 64位

服务器配置：CUP： 1核 内存：1GB 公网带宽：1Mbps 硬盘：20G

应用服务器：Windows Servers 2008

服务器配置：CUP： 1核 内存：2GB 公网带宽：1Mbps 硬盘：40G

网络架构：完全支持TCP/IP协议

开发工具或技术体系：开发语言：Python 3.6，开发工具：Pycharm 2017

数据库： MongoDB 3.4.3

软件运行环境说明：

设备：

客户程序硬件要求：

具有 1核处理器且满足以下要求的计算机：

最低 1G内存

最小 20 GB 硬盘

web服务器硬件需求：

具有1核处理器且满足以下要求的计算机：

最低 1G内存

最小 20 GB 硬盘

总线I/O：8M/s；

数据库服务器硬件需求：

具有1核处理器且满足以下要求的计算机：

最低 1G内存

最小 20 GB 硬盘

2.总体要求

2.1 系统功能概述

从互联网上抓取事件，对事件数据进行数据处理，存储到数据库，进行分词及语义等处理，提取事件的属性建立事件模型，以及可视化展现。

1、实现互联网事件天级或更高频次抓取，采集政治会议、展会、体育赛事、演唱会、突发异常天气等各类中比较主要的事件，每个类型的事件数据至少来自2个数据源（网站），每天爬取一次。

2、实现事件的去重功能，一是不同数据源（网站）的事件去重，二是不同天抓取的事件去重。

3、事件画像建模，即事件属性自动化提取。

4、使用DataV进行可视化展现。

2.2 系统功能要求

1、网络爬虫模块实现互联网事件抓取。

2、日志模块实现各个模块间日志的生成。

3、数据处理模块实现数据的准备、清洗、去重、转换。

4、数据建模模块对数据建立模型，计算及转换。

5、事件画像模块对事件分词及提取属性。

6、DataV进行可视化展示。

3.软件开发

3.1 软件需求分析

系统需求分析：为航空公司飞机的运力投放、航班编制、票价策略提供服务。

软件系统结构描述：基于互联网大数据的事件智能抓取和画像系统由爬虫模块、日志模块、数据处理模块、数据建模模块、事件画像模块、可视化系统构成。

软件结构如图3-1:

图3-1 系统总用例图

数据流程如图 3-2：

图 3-2 数据流程

3.2 软件的概要设计

3.2.1 软件概要设计说明

软件系统采用B/S架构，并且将程序部署在云服务器。

3.2.2 基本设计概念和处理流程

考虑到互联网上的数据复杂性非常高、并且事件数据一般为非结构化数据，其处理和分析有一定的难度，对爬虫的稳定性和爬取速度有很大的要求，我们使用scrapy爬虫框架技术来从各网站爬取数据，对数据进行处理，使用NoSQL型数据库MongoDB存储半结构化数据，对数据画像、分析、建模并且将程序部署在云端。通过访问云端数据库，数据流映射到DataV实现可视化展示。

系统流程如图 3-2-2：

图 3-2-2 系统流程图

设计说明：

1、每一个计算机需要不需要安装客户程序，但是需要有IE4.0或更高版本的支持；

2、WEB发布服务器访问数据库服务器，数据库服务器对外部不可见；

3、数据库服务器使用MongoDB来实现，对于目前的访问量，MongoDB在足够的硬件环境的支持下能够适用，并且在经济上也是合理的；

4、多用户并发访问和处理、数据加锁、事务协调，由MongoDB数据库来完成，本系统不提供单独的事务处理服务器；

5、scrapy爬虫框架可以实现快速、高并发、高层次的网络抓取。

3.3 软件的详细设计

3.3.1 系统结构

应用程序采用Python语言进行开发，网络爬虫使用scrapy框架进行开发并将其部署在云服务器上，考虑到爬虫抓取的数据多为半结构化或者非结构化数据，我们使用NoSQL型数据库MongoDB进行数据存储，并部署在云服务器上。

系统设计如图 3-3-1：

图 3-3-1 系统设计图

3.3.2 模块设计说明

整个系统共划分为6个模块

1、爬虫模块

2、日志模块

3、数据处理

4、数据建模

5、事件画像

6、可视化展示

系统模块设计如下：

1、爬虫模块分为定时爬虫模块和scrapy爬虫两个模块构成。

定时爬虫模块：管理整个爬虫模块，监控爬虫运行状态、设置爬虫抓取频率（每天爬取一次）、爬虫程序异常处理、管理爬虫日志。

Scrapy爬虫模块：从目标网站上抓取数据，采集政治会议、展会、体育赛事、演唱会、突发异常天气、交通管制新闻网等数据源网站的事件经过数据处理，并生成爬虫日志存储到数据库。此模块由11个爬虫脚本组成，分别对相应的数据源进行数据爬取。

爬虫模块如图3-3-2：

图3-3-2 爬虫模块图

2、日志模块：日志模块与系统各个模块部分联系紧密，各个模块运行都会产生日志，生成的日志将存储到数据库，方便系统管理、维护、排错。

日志设计图如图 3-3-3：

图3-3-3 日志模块设计图

3、数据处理：数据处理分为数据准备、数据转换、数据聚合。主要对非结构化/半结构化数据进行处理，得到干净、规整的数据。爬虫爬取网站数据源的时候进行数据预处理，对所收集数据进行审核、筛选、排序等操作。数据预处理完成后对数据进行清洗，过滤掉不符合要求的数据，将脏数据转化为满足要求的数据。再进行缺失值处理，对缺失项进行特殊值填充，存储到数据库。数据去重主要对不同网站的事件数据去重复处理。

4、数据建模：对事件数据建立一个统一的模型，利用聚类等机器学习算法挖掘数据间隐藏的属性及关系。由聚类算法和搜索引擎收录数两个子模块构成。

聚类算法：使用无监督学习的K-Means对数据进行聚类分析。

搜索引擎收录数：对于热度相关数据的缺失，我们通过抓取百度搜索引擎对事件的收录数，对缺失热度数据进行填充。

5、事件画像：事件画像模块实现了对事件属性的自动化提取。调用数据建模模块对数据进行聚类，对不同类型的事件进行分词及属性提取，数据样本初始化，日志生成，对事件画像，生成事件样本。

事件属性表如下：

6、可视化展示我们使用阿里云的可视化工具DataV来生成图表和数字大屏。

3.3.3 爬虫模块

定时爬虫模块设计如图3.3.3：

图3.3.3 定时爬虫模块

程序定时及爬虫管理脚本 TimerAdmins.py

import multiprocessing
import time
import pymongo
from SpiderAdmin import CrawlAdmin
from Log import LogUtils

class ProcessingTest(multiprocessing.Process):

    host = ''       #目标IP
    port = 0        #端口号

    def __init__(self,sleep):
        multiprocessing.Process.__init__(self)
        self.sleep=sleep
        self.ConfigDB='Config'
        self.ConfigTdb='timer'

    #程度运行
    def run(self):
        log = LogUtils()
        client = pymongo.MongoClient(host=self.host, port=self.port)
        db = client[self.ConfigDB]
        table = db[self.ConfigTdb]
        while True:
            ''' 得到当前时间戳'''
            times=time.time()
            '''得到当前时间戳去小数'''
            tim=int(str(times).split('.')[0])
            '''得到当前日期'''
            date=tim//86400
            '''从数据库查询日期'''
            info=table.find_one({"config": "timer"})
            print('data----------------------->'+str(date ))
            dateInfo=-1
            '''如果数据库没有记录则保存一下'''
            if info==None:
                print('没有数据')
                log.I('TimerAdmins','第一次运行数据库里没有数据')
                table.insert({"config": "timer","time":date})
                p = CrawlAdmin(1)
                p.start()
                print("已经启动爬虫模块")
                log.I('TimerAdmins', '已经启动爬虫模块')
                time.sleep(self.sleep)

            else:
                '''
                如果数据库有记录则对比上面获取的当前日期
                '''
                print(info)
                dateInfo=int(info['time'])
                ''' 如何当前日期大于数据库日期 '''
                print("------------------------"+str(dateInfo))
                if date>dateInfo:
                    timers=tim%86400
                    print('timers'+str(timers))
                    if date-dateInfo==1:
                        if timers>21600:
                            info['time']=date
                            table.save(info)
                            p=CrawlAdmin(1)
                            p.start()
                            print("已经启动爬虫模块---")
                            log.I('TimerAdmins', '已经启动爬虫模块')
                    else:
                        info['time'] = date-1
                        table.save(info)
                        p = CrawlAdmin(1)
                        p.start()
                        print("已经启动爬虫模块---")
                        log.I('TimerAdmins', '已经启动爬虫模块')
                    time.sleep(self.sleep)
                else:
                    print('数据已是最新,不用更新')
                    log.I('TimerAdmins', '数据已是最新,不用启动爬虫模块更新')
                    time.sleep(self.sleep)

if __name__ =="__main__":
    print('时间管理员开始运行')
    p=ProcessingTest(900)
    p.start()
    print(p.pid)

scrapy爬虫模块设计如图 3.3.4：

图3.3.4 Scrapy爬虫模块类和接口设计

3.3.4 日志模块

日志模块设计如图 3.3.4：

图3.3.4 日志接口类图

算法及源码设计如下：

import pymongo
import time
import traceback
class  LogUtils():
  
    host = ''      #目标主机IP
    port = 0      #端口号

    def __init__(self):
        self.LogDB='Log'
        self.Table=''
        self.client=pymongo.MongoClient(host=self.Host,port=self.port)
        self.db=self.client[self.LogDB]

    '''
    普通日志信息
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''
    def InfoLog(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'Info','time':OtherStyleTime})

        except:
            traceback.print_exc()

    '''
    普通日志信息 的重载方法  简便写法
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''

    def I(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'Info','time':OtherStyleTime})

        except:
            traceback.print_exc()

    '''
    错误日志信息 
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''
    def ErrorLog(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'Error','time':OtherStyleTime})

        except:
            traceback.print_exc()
    '''
    错误日志信息 的重载方法  简便写法
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''
    def E(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'Error','time':OtherStyleTime})

        except:
            traceback.print_exc()

    '''
    调试日志信息 
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''
    def DeBugLog(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'DeBug','time':OtherStyleTime})

        except:
            traceback.print_exc()
    '''
    调试日志信息 的重载方法  简便写法
    table  :  日志的表名 统一写类名
    LogInfo:  日志的内容
    '''
    def D(self,Table,LogInfo):
        try:
            self.Table=Table
            table=self.db[self.Table]
            times=str(time.time()).split('.')[0]
            timeArray=time.localtime(int(times))
            OtherStyleTime=time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
            table.insert({'logInfo':LogInfo,'Grade':'DeBug','time':OtherStyleTime})
        except:
            traceback.print_exc()

3.3.5 数据处理

数据处理脚本文件 ToHeavy.py

数据去重设计如图 3.3.5：

图3.3.5 数据去重接口和类图

数据去重算法说明：根据表名查询数据库对应的表，获取该条事件过去三天所有数据，对事件名分词，如果事件名与过去三天的事件记录相似度超过65%，标记为重复数据，flag赋值为0。

import jieba
from datetime import *
from pymongo import MongoClient
import time
from OperatingDB import OperatingDB


def connDB(ip, port, tableName, base):
    db = OperatingDB(ip, port)
    table = db.createTable(tableName, base)
    return table
    

#得到过去三天的日期（以字符串形式添加到列表）
def past_three_days(time, daynum, pastday_lit):
    date_time = datetime.strptime(time, '%Y-%m-%d')
    for i in range(daynum):
        pastday = date_time - timedelta(i)
        strpastday = datetime.strftime(pastday, '%Y-%m-%d')
        pastday_lit.append(strpastday)

#查询过去三天的数据
def pastThreeDayData(table, pastday_lit):
    past_one_day = {}
    past_two_day= {}
    past_three_day = {}
    key = '开始日期'

    past_one_day[key] = pastday_lit[0]
    past_two_day[key] = pastday_lit[1]
    past_three_day[key] = pastday_lit[2]

    data = table.find({'$or':[past_one_day, past_two_day, past_three_day]})
    title_lit = []
    for i in data:
        title_lit.append(i['事件名称'])
 
    return title_lit
    

#返回 flag，如果 flag = 0，则表示是重复数据   
def toheavy(table, title, titles):
    
    #对标题分词处理
    title_Participle = jieba.lcut(title)
    
    for title in titles:
        count = 0
        title_tmp = jieba.lcut(title)
        for i in title_Participle:
            if i in title_tmp:
                count += 1
        frequency = count/len(title_Participle)*100
        if(frequency > 65):
            print('相似度超过65％， 去重')
            flag = 0

    if flag == 1:
        print('数据无重复')
    return flag

3.3.6 数据建模

3.3.6.1 聚类算法

数据建模说明：我们采用机器学习算法的无监督学习算法，对原始数据建立分类模型， 使用聚类分析算法来对数据进行建模。

数据说明：在我们抓取到的数据中有关于热度的字段，例如下图的中国会展门户网站的一条数据，有关注指数的数据字段，可是单凭原始数据却无法判断所属热度的级别，无法直接划分热度级别。

中国会展门户数据如图3.3.6.1：

图3.3.6.1 中国会展门户数据图

K-Means 聚类算法说明：在具体的聚类算法中我们采用K-Means聚类算法，对数据建模，将事件热度分为三类，既聚类热度级别为 1、2、3。K-Means算法是基于距离的非层次聚类算法，在最小化误差函数的基础上将数据划分为预定的类数K，采用距离作为相似性的评价指标，既认为两个对象的距离越近，相似度就越大。度量样本之间的相似性使用的是欧氏距离，公式如图 3.3.6.2：

图3.3.6.2 欧氏距离公式图

具体算法描述如图 3.3.6.3：

图3.3.6.3 算法描述

聚类算法流程如图 3.3.6.4：

图 3.3.6.4 聚类算法流程图

建模程序设计及算法说明: KMeans.py 聚类算法文件。

聚类算法设计接口如图 3.3.6.5：

图3.3.6.5 聚类算法设计接口和类图

K-Means聚类算法设计源码如下：

#-*- coding: utf-8 -*-
import pandas as pd
from sklearn.cluster import KMeans
import xlrd
import openpyxl
import matplotlib.pyplot as plt

class Kmeans:
    '''数据聚类'''

    k = 3                   #聚类的类别数（内置）
    iteration = 500         #聚类最大循环次数（内置）
    jobs = 4                #设置并发数（内置）

    def readData(self, inputfile):
        '''从磁盘读取数据'''
        self.inputfile = inputfile
        #读取数据
        data = pd.read_excel(self.inputfile)
        # 去掉无用字段
        data.drop(['事件名称','开始时间'], 1, inplace=True)
        return data

    def writeData(self, outputfile, data):
        '''写入文件'''
        self.outputfile = outputfile
        data.to_excel(self.outputfile)


    def KMeansCompute(self, data):
        '''K-Means聚类计算'''
          
        #数据标准化
        data_zs = 1.0 * (data - data.mean())/data.std()

        #分析为K类， 并发数4
        model = KMeans(n_clusters = self.k, n_jobs = self.jobs, max_iter = self.iteration)
        model.fit(data_zs)  #开始聚类

        r1 = pd.Series(model.labels_).value_counts()
        r2 = pd.DataFrame(model.cluster_centers_)   #找出聚类中心
      
        r = pd.concat([r2, r1], axis = 1)   #横向连接
        r.columns = list(data.columns) + ['类别数目']
        
        #详细输出
        r = pd.concat([data, pd.Series(model.labels_, index = data.index)], axis = 1)
        r.columns = list(data.columns) + ['聚类类别']   #重命名表头
        
        return r

聚类完成后，根据事件的主办方级别、主办方类型及影响范围属性对聚类热度进行加权，得到热度属性。

3.3.6.2 搜索引擎收录数

在抓取其他数据源的时候会遇到热度相关字段的缺失，搜索引擎收录数一定程度上映射了事件的热度属性，既越热门的事件收录数越多，我们对百度搜索引擎事件收录数进行量化，根据事件的主办方级别、主办方类型及影响范围属性对聚类热度进行加权值来得出该事件的热度值。

获取搜索引擎收录数文件：GetSearchEngineResult.py

import re
import requests

class GetSearchEngineResult:
#获取百度搜索搜索引擎结果数
    def getHTMLText(self, url):
        try:
            r = requests.get(url, timeout = 10, headers = {'user-agent' : 'Mozilla/5.0'})
            r.raise_for_status()
            return r.text
        except:
            print("解析百度结果异常")

    def getBaiduResult(self, title):
        baseURL = 'http://www.baidu.com/'
        url = baseURL + 's?' + 'wd=' + title

        html = self.getHTMLText(url)
        regex = r'百度为您找到相关结果.*?个'
        numRegex = r'[0-9]'
        data = re.search(regex, html)
        heatStr = ''
        if data:
            num = re.findall(numRegex, data.group())
            for i in num:
                heatStr += i
        heat = self.getBaiduHeat(eval(heatStr))

        return heat
             



 


    

3.3.7 事件画像

3.3.7.1 事件画像系统设计

事件画像系统集成了事件画像管理脚本、数据样本初始化、事件样本输出、数据建模、事件画像等功能。事件画像系统调用数据建模模块，提取各类事件的属性，生成事件样本。
事件画像系统设计如图 3.3.7.1：

图 3.3.7.1事件画像系统设计图

3.3.7.2事件画像

事件画像模块的主要类是实体类、数据访问接口和功能类。

实体类保存了事件的基本属性数据，访问接口连接数据库，功能类 对事件提取属性。

事件画像设计及接口类如图 3.3.7.2：

图 3.3.7.2 事件画像模块接口和类图

3.3.8 可视化展示

我们使用阿里的DataV做可视化展示，通过DataV建立云端数据库的连接，实现数据流映射到DataV。从而生成数据大屏。

可视化展示预览图如图 3.3.8：

图 3.3.8 数据大屏

3.4数据库设计

3.4.1 数据库说明

考虑到程序的稳定性和团队协同工作等特性，我们将数据库部署在云服务器，实现了实时访问、高性能、高扩展性等特点。

数据库软件：MongoDB
建立的数据库名称: Spider、Config、DataV、Log
存储爬虫抓取的数据： Spider
系统配置数据库： Config
存储可视化展示数据的库： DataV
存储日志数据： Log

3.4.2 数据库操作

将对数据库的操作封装为一个模块。各个模块都要进行数据的存储，将数据的存储单独划分出来做成一个模块的好处是显而易见的，实现了系统模块间的弱耦合，方便数据的写入、读取等操作。

** ** ConnectMongoDB.py 功能：连接mongodb数据库

连接数据库接口源码：

from pymongo import MongoClient

class ConnectMongo:
    '''连接数据库'''

    client = None
    
    # ipaddr:IP地址， port：端口号
    def connect(self, ipaddr, port):    #建立连接
        self.client = MongoClient(ipaddr, port)

    def close(self):                      #关闭连接
        return self.client.disconnect()
    
    def getConn(self):                  #返回连接
        return self.client

        

OperatingDB.py 功能：封装了对数据库的操作，创建表\集合、插入数据、删除数据、查询数据、关闭数据库连接。

from ConnectMongoDB import ConnectMongo

class OperatingDB:
    
    '''操作Mongodb数据库'''
  
    def __init__(self, ipaddr, port):
        conn = ConnectMongo()
        conn.connect(ipaddr, port)
        self.client = conn.getConn()

    #tableName:表名， base：数据库名
    def createTable(self, tableName, base):
        '''创建数据库和表'''
        self.crawl = self.client[base]
        self.table = self.crawl[tableName]
        return self.table

    #data：插入的数据
    def insertDatas(self, data):
        self.table.insert(data)
              
    def deleteData(self, data):
        '''删除数据'''
        self.table.remove(data)
    
    #q：查询条件，projecttion：查询字段。
    def query_one(self, q = {}, projection = {'_id' : 0}):
        '''查询一条数据'''
        return self.table.find_one(q, projection)
        
    def query(self, q = {}, projection = {'_id' : 0}):
        '''查询数据'''
        return self.table.find(q, projection)

    def closeConn(self):
        '''关闭连接'''
        self.client.close()
        

3.4.3数据库结构

由于NoSQL型数据库不同于传统的关系型数据库，在建立表结构、索引这些操作时没有像关系型的关联、约束等关系。结构设计也相对简单。

数据库设计如下表

3.4.4 表结构

MongoDB 将数据存储为一个文档/表，数据结构由键值(key=>value)对组成。MongoDB 文档/表类似于 JSON 对象。数据库各个表字段设计如下。

数据库：Spider

表名：CityWeather

表名：DamaiConcert、JuchengConcert、YongleConcert

表名：DamaiSports

表名：Longitudes

表名：WaringWeather

表名：XishiquConcert、XishiquSports

表名：YongleSports

表名：cnena

表名：eshow

表名：people

表名：trafficcontrol

表名：xinhuanet

数据库：Config

表名：timer

数据库：Log

表名：CityWeather、ConcertAttr、CrawlAdmin、DaMaiPW、EventPortrait、EventPortraitAdmin、

ExhibitionAttr、JuChenSpider、SportAttr、TimerAdmin、WarngingCrawl、XishiquConcert、XishiquSports、people、xinhuanet、yonglePW。

数据库：DataV

表名：DataV