软工实践|结对第二次—文献摘要热词统计及进阶需求
班级：软件工程1916|W
作业：结对第二次—文献摘要热词统计及进阶需求
结对学号：221600418 黄少勇、 221600420 黄种鑫
课程目标：学会使用Git、提高团队协作能力
Github地址：基础需求、进阶需求
分工：
- 黄少勇--词频统计代码实现，性能优化
- 黄种鑫--爬虫代码实现，可视化实现，单元测试
目录
Github 签入记录
基本需求：
进阶需求：
PSP
| PSP2.1 | Personal Software Process Stages | 预估耗时（分钟） | 实际耗时（分钟） |
|---|---|---|---|
| Planning | 计划 | 10 | 10 |
| • Estimate | • 估计这个任务需要多少时间 | 10 | 10 |
| Development | 开发 | 750 | 980 |
| • Analysis | • 需求分析 (包括学习新技术) | 120 | 150 |
| • Design Spec | • 生成设计文档 | 20 | 20 |
| • Design Review | • 设计复审 | 10 | 10 |
| • Coding Standard | • 代码规范 (为目前的开发制定合适的规范) | 10 | 10 |
| • Design | • 具体设计 | 30 | 40 |
| • Coding | • 具体编码 | 400 | 550 |
| • Code Review | • 代码复审 | 100 | 120 |
| • Test | • 测试（自我测试，修改代码，提交修改） | 60 | 80 |
| Reporting | 报告 | 50 | 50 |
| • Test Report | • 测试报告 | 20 | 20 |
| • Size Measurement | • 计算工作量 | 10 | 10 |
| • Postmortem & Process Improvement Plan | • 事后总结, 并提出过程改进计划 | 20 | 20 |
| 合计 | 810 | 1040 |
解题思路
在拿到这个题目后，我们俩通过分析，确定基本需求即为进阶需求的特例（进阶需求中， -m 参数的值取为 1， -n 参数的值取为 10， -w 参数的值取为 0 即为基本需求的要求），所以我们一开始就确定直接开发进阶需求，通过给定参数默认值的方式，完成基本需求的任务。
本次需求包含三部分：字符统计、单词（词组）统计、行数统计，而这三个可以看成一个连续的过程，所以我们的思路一开始也是想把三部分整合在一起完成，即：打开一次文件，按行读取（实现了行数统计），将读取出来的行，进行字符统计，并且使用 String.split() 方法将整行切割为单词，实现单词的统计，进而按照给定的 -m 参数，将分隔完的单词进行拼装，统计出长度为m的词组。但是后来详细分析需求后，发现题目要求将三个功能独立出来，所以最终决定把三个功能分开实现，即：实现三个方法，分别实现打开文件并统计字符、单词（词组）、行数。
另外，为了使处理命令行参数和词频统计等功能分隔开，并且实现相对独立，我们决定实现一个 Signal 类。该类主要完成对命令行的分析，为词频统计提供参数。
设计实现过程
由以上思路可以得到，我们需要两个类—— WordCount 类及 Signal 类。WordCount 类中至少实现三个方法：字符统计、单词（词组）统计、行数统计， Signal 类至少实现一个方法：命令行分析。类图设计如下：
词频统计流程图：
行数、字符数统计流程图：
性能分析及优化
以下测试均使用爬取得到的2018年CVPR论文数据，使用参数 -m 2，使用工具JProfiler得到。
概览：
优化前各方法耗时：
通过分析各个方法的耗时情况，我们得到，程序的瓶颈主要在 WordCount.setWordNumber() 方法上，因此我们着重对该方法优化。
private void setWordNumber() {
String line;
try (BufferedReader br = new BufferedReader(new FileReader(inFile))) {
while ((line = br.readLine()) != null) {
line = line.toLowerCase();
// 按行读取，并判断是否为Title行
if (line.indexOf("title:") == 0) {
weight = signal.getwValue();
line = line.replaceFirst("title:", "");
}
if (line.indexOf("abstract:") == 0) {
weight = 1;
line = line.replaceFirst("abstract:", "");
}
splitLine(line); // 将每一行进行拆分处理
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 判断一个单词是否是题目要求的合法单词
private boolean isWord(String s) {
return s.length() >= 4 && Character.isLetter(s.charAt(0)) && Character.isLetter(s.charAt(1)) && Character.isLetter(s.charAt(2)) && Character.isLetter(s.charAt(3));
}
private void splitLine(String line) {
if(line.isEmpty()){
return;
}
if(Character.isLetterOrDigit(line.charAt(0))) {
deviation = -1;
}
else {
deviation = 0;
}
String[] str = line.split("[^a-z0-9]"); // 切割得到每个单词
for (String aStr : str) {
if (!"".equals(aStr)) { // 去掉切割产生的空白后，将单词加入arrayList待后续组词使用
arrayList.add(aStr);
if (isWord(aStr)) { // 判断单词单词是否合法
wordNumber += 1;
}
}
}
str = line.split("[a-z0-9]"); // 切割得到单词间的分隔符
for(String aStr : str) {
if(!"".equals(aStr)) {
separator.add(aStr);
}
}
setMap(); // 拼接单词，组成长度为m的词组
arrayList.clear();
separator.clear();
word.clear();
}
通过观察JProfiler的数据，我们发现， WordCount.setWordNumber() 中，耗时最多的为 WordCount.splitLine() 中的 String.split() 耗时最多。
查阅资料后，网上对于 split() 方法的优化，主要是使用 String.indexOf() 方法或 StringTokenizer() 方法实现，但是这两个方法一次仅能查找一个分隔符，而本次作业中分隔符种类较多，自行实现起来可能较为麻烦，而且我们查阅了JAVA中的 split() 源码，发现其也是采用的 indexOf() 实现，故我们放弃了手动使用 indexOf() 实现分割。
最后，我们尝试将 split() 的调用，改为使用正则实现：
private void splitLine(String line) {
// ...
Pattern r = Pattern.compile("[a-z0-9]+");
Matcher m = r.matcher(line);
while (m.find()){
arrayList.add(m.group(0));
if (isWord(m.group(0))) {
wordNumber += 1;
}
Pattern r2 = Pattern.compile("[^a-z0-9]+");
Matcher m2 = r2.matcher(line);
while (m2.find()){
separator.add(m2.group(0));
}
// ...
}
改用正则优化第一次后各方法耗时：
使用正则后，时间少了 500ms 左右，算是有些许优化，但是效果并不明显，所以我们针对耗时第二多的 isWord() 方法进行改进。 isWord() 虽然简单，但是由于调用次数过多（每个单词都得调用两次），所以总耗时过大。我们通过加入一个辅助数组，用来记录每个单词是否合法，这样子可以把 isWord() 的调用次数变为原来的一半。修改如下：
private void splitLine(String line) {
// ...
while (m.find()){
arrayList.add(m.group(0));
if (isWord(m.group(0))) {
wordNumber += 1;
isLegalWord.add(true); // 如果是合法单词，就把对应位置为true
}
else{
isLegalWord.add(false);
}
}
// ...
setMap();
// ...
}
private void setMap() {
combineWord();
// ...
}
// 将单词拼接为长度为m的词组
private void combineWord() {
for (int i = 0; i < arrayList.size() - signal.getmValue() + 1; i++) {
boolean flag = true;
for (int j = 0; j < signal.getmValue() && flag; j++) {
if (!isLegalWord.get(i+j)) {
flag = false;
}
}
// ...
}
}
优化第二次后各方法耗时：
加入辅助数组后，时间又减少了 500ms 左右。
至此，在两次优化后，运行时间能够减少 1s 左右。
关键代码
行数统计
// 提供一个获取行数的接口，供外部调用
public int getLineNumber() {
return lineNumber;
}
// 生成行数，为私有方法，供构造函数调用
private void setLineNumber() {
String line;
try (BufferedReader br = new BufferedReader(new FileReader(inFile))) {
while ((line = br.readLine()) != null) { // 按行读取文件
if(!line.trim().isEmpty()){ // 去掉行首行尾的空白后，判断是否为空行
lineNumber++;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
字符数统计
// 提供一个获取字符数的接口，供外部调用
public int getCharacterNumber() {
return characterNumber;
}
// 生成字符数，为私有方法，供构造函数调用
private void setCharacterNumber() {
int ch;
try (FileReader fr = new FileReader(inFile)) {
while ((ch = fr.read()) != -1) { // 逐字节读取文本
if(ch != 13){ // 如果读取到的字符不为 \r 时字符数加1
// 因为题目要求的换行符为\r\n（为一个整体），
// 如果不跳过其中一个，会导致最终字符数会比实际字符数多出一倍行数，
// 所以选择其中的一个即可，我们选择了 \r。
characterNumber++;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
单词数（词频）统计
// 提供一个获取单词数的接口，供外部调用
public int getWordNumber() {
return wordNumber;
}
// 生成单词数，为私有方法，供构造函数调用
private void setWordNumber() {
String line;
try (BufferedReader br = new BufferedReader(new FileReader(inFile))) {
while ((line = br.readLine()) != null) {
// 逐行读取，并将每行的内容转为小写，便于后续处理
line = line.toLowerCase();
// 判断是否为Title行或者Abstract行，调整权重，用于统计词频（如果为基础需求，默认的权重为1）
if (line.indexOf("title:") == 0) {
weight = signal.getwValue();
line = line.replaceFirst("title:", "");
}
if (line.indexOf("abstract:") == 0) {
weight = 1;
line = line.replaceFirst("abstract:", "");
}
splitLine(line); // 将每一行进行拆分处理
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 判断一个单词是否是题目要求的合法单词
private boolean isWord(String s) {
return s.length() >= 4 && Character.isLetter(s.charAt(0)) && Character.isLetter(s.charAt(1)) && Character.isLetter(s.charAt(2)) && Character.isLetter(s.charAt(3));
}
private void splitLine(String line) {
if(line.isEmpty()){
return;
}
// 判断首字母是否为字母，用于后续拼接词组时，将单词与分隔符正确拼接
if(Character.isLetterOrDigit(line.charAt(0))) {
deviation = -1;
}
else {
deviation = 0;
}
// 正则匹配单词
Pattern r = Pattern.compile("[a-z0-9]+");
Matcher m = r.matcher(line);
while (m.find()){
arrayList.add(m.group(0)); // 将单词加入arrayList待后续组词使用
if (isWord(m.group(0))) {
wordNumber += 1;
isLegalWord.add(true); // 如果是合法单词，就把对应位置为true
}
else{
isLegalWord.add(false);
}
}
// 正则匹配分隔符
Pattern r2 = Pattern.compile("[^a-z0-9]+");
Matcher m2 = r2.matcher(line);
while (m2.find()){
separator.add(m2.group(0));
}
setMap(); // 拼接单词，组成长度为m的词组
// 清空本行的内容，等待处理下一行
arrayList.clear();
separator.clear();
word.clear();
isLegalWord.clear();
}
// 将单词拼接为长度为m的词组，并统计词组词频
private void setMap() {
combineWord();
for (String aWord : word) {
if (map.containsKey(aWord)) {
map.put(aWord, map.get(aWord) + weight);
} else {
map.put(aWord, weight);
}
}
}
// 将单词拼接为长度为m的词组
private void combineWord() {
for (int i = 0; i < arrayList.size() - signal.getmValue() + 1; i++) {
boolean flag = true;
// 判断从i开始的m个单词是否均为合法单词，若是，则可组成一个长度为m的词组
for (int j = 0; j < signal.getmValue() && flag; j++) {
if (!isLegalWord.get(i+j)) {
flag = false;
}
}
if (flag) {
// 如果可拼接成长度为m的词组，则将这m个单词与其中的分隔符进行拼接
StringBuilder s = new StringBuilder(arrayList.get(i));
for(int j = 1; j < signal.getmValue(); j++) {
s.append(separator.get(i + j + deviation)).append(arrayList.get(i + j));
}
word.add(s.toString());
}
}
}
爬虫部分
爬虫使用的是JAVA实现，由于对于一些爬虫框架并不熟悉，所以使用的是JAVA原生的URL类请求网页内容，使用正则进行数据匹配。代码如下：
// 封装的请求函数，用于发起请求并返回页面HTML内容
private static String getHtmlContent(String uri) {
StringBuilder result = new StringBuilder();
try {
String baseURL = "http://openaccess.thecvf.com";
URL url = new URL(baseURL + "/" + uri);
URLConnection connection = url.openConnection();
connection.connect();
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String line;
while ((line = in.readLine()) != null) {
result.append(line);
}
} catch (IOException e) {
e.printStackTrace();
}
return String.valueOf(result);
}
public static void main(String[] args) {
// 加载论文类型的 CSV 表格
// 由于未在官网上找到论文类型，因此使用在Github(https://github.com/amusi/daily-paper-computer-vision/blob/master/2018/cvpr2018-paper-list.csv)上其他人搜集好的数据
Map<String, String> map = new HashMap<>();
try (BufferedReader bufferedReader = new BufferedReader(new FileReader(new File("cvpr/cvpr2018-paper-list.csv")))) {
String line;
// 逐行读取CSV表格，并切割得到其论文类型及论文名，并以论文名为键，论文类型为值，生成一个HashMap
while ((line = bufferedReader.readLine()) != null) {
String[] list = line.split(",");
map.put(list[2].toLowerCase(), list[1]);
}
} catch (IOException e) {
e.printStackTrace();
}
// 获取CVPR官网首页内容
String result = getHtmlContent("CVPR2018.py");
// 获取到首页后，使用正则匹配，得到论文详细内容的链接，并逐个发起请求，继续使用正则匹配详情页，得到论文题目、摘要、作者信息等内容
/*
首页HTML样式
<dt class="ptitle"><br><a href="content_cvpr_2018/html/Das_Embodied_Question_Answering_CVPR_2018_paper.html">Embodied Question Answering</a></dt>
*/
/*
详情页HTML样式
<div id="papertitle">title</div><div id="authors"><br><b><i>authors</i></b>; where</div><font size="5"><br><b>Abstract</b></font><br><br><div id="abstract" >abstract</div><font size="5"><br><b>Related Material</b></font><br><br>[<a href="url">pdf</a>]
*/
String pattern = "<dt class=\"ptitle\"><br><a href=\"(.*?)\">(.*?)</a></dt>";
String pattern2 = "<div id=\"papertitle\">(.*?)</div><div id=\"authors\"><br><b><i>(.*?)</i></b>; (.*?)</div><font size=\"5\"><br><b>Abstract</b></font><br><br><div id=\"abstract\" >(.*?)</div><font size=\"5\"><br><b>Related Material</b></font><br><br>\\[<a href=\"(.*?)\">pdf</a>]";
Pattern r = Pattern.compile(pattern);
Pattern r2 = Pattern.compile(pattern2);
Matcher m = r.matcher(result);
StringBuilder res = new StringBuilder();
int i = 0;
while (m.find()) {
String html = getHtmlContent(m.group(1));
System.out.println(i);
System.out.println("URL: " + m.group(1));
Matcher m2 = r2.matcher(html);
if (m2.find()) {
// 输出详细内容
System.out.println("Title: " + m2.group(1));
System.out.println("authors: " + m2.group(2));
System.out.println("Type: " + map.get(m2.group(1).split(",")[0].toLowerCase()));
System.out.println("Where: " + m2.group(3));
System.out.println("Abstract: " + m2.group(4));
System.out.println("PDF: " + m2.group(5).replace("../../", "http://openaccess.thecvf.com/"));
res.append(i).append("\r\n");
// res.append("Type: ").append(map.get(m2.group(1).split(",")[0].toLowerCase())).append("\r\n");
res.append("Title: ").append(m2.group(1)).append("\r\n");
// res.append("Authors: ").append(m2.group(2)).append("\r\n");
res.append("Abstract: ").append(m2.group(4)).append("\r\n");
// res.append("PDF: ").append(m2.group(5).replace("../../", "http://openaccess.thecvf.com/")).append("\r\n\r\n\r\n");
}
System.out.println();
System.out.println();
i++;
}
// 将内容写入文件
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File("cvpr/result.txt")))) {
bufferedWriter.write(String.valueOf(res));
} catch (IOException e) {
e.printStackTrace();
}
}
爬虫结果展示：
单元测试
使用 JUnit4 进行单元测试，测试了词频统计部分主要的四个函数，即：
WordCount.getCharacterNumber()：字符数统计WordCount.getLineNumber()：行数统计WordCount.getWordNumber()：单词数统计WordCount.getList()：词频统计
测试数据集为十个文本，分别为：空文本、全为空行的文本、字母数字分隔符随机交替出现的文本、混有空行的文本、混有非单词的文本、正常的单词文本等。
单元测试结果及代码覆盖率如下图：
覆盖率中，WordCount 类由于存在比较多的异常处理分支，故覆盖率只有86%，而命令行处理类 Signal 类由于在单元测试时未指定所有参数，故覆盖率也较低。
部分测试数据
测试数据：
file123&&&file123
123file
aaa
AAA
aaaa
AAAA
AaAa
测试结果：
charactors: 49
words: 5
lines: 7
<file123&&&file123>: 1
测试数据：
as!@#$!@$rwehhhkk***---===++==++
\t\n
\r\n
mmm&^&&&^^^
测试结果：
charactors: 38
words: 3
lines: 3
<aaaa>: 1
<fefeffffff>: 1
<file1daa>: 1
测试数据：
abcdefghijklmnopqrstuvwxyz
1234567890
,./;'[]\<>?:"{}|`-=~!@#$%^&*()_+
测试结果：
charactors: 76
words: 1
lines: 3
<abcdefghijklmnopqrstuvwxyz>: 1
遇到的困难及解决方法
困难描述
- 对于正则表达式不够熟练，使用起来不够顺手
- 对于爬虫框架不熟，爬虫代码可能较为啰嗦
解决尝试
查阅网上博客及相关教程
是否解决
正则相关已解决，爬虫框架由于时间问题没有深入了解
收获
对于正则表达式，有了进一步的认识，同时对于爬虫相关的东西也有了初步的印象，后续有时间可多多接触下。
评价你的队友
我的队友的知识面涉及很广，学习和使用新事物的能力很强，配合很愉快
附加题
爬虫拓展
从网站综合爬取论文的除题目、摘要外其他信息。
由于未在官网上找到论文类型，因此使用在 Github 上其他人搜集好的数据。最终结果如下：
数据可视化
实现了论文作者的关系图。关系图使用 ECharts 框架实现可视化效果。数据来自爬虫得到的论文数据集，使用Java将原始数据生成ECharts所需要的XML数据格式。HTML代码如下：
<html>
<head>
<meta charset="utf-8">
<script src="echarts.js"></script>
<script src="dataTool.min.js"></script>
<script src="jquery-3.3.1.js"></script>
</head>
<body>
<div id="main" style="width: 100%;height:110%;"></div>
<script type="text/javascript">
var myChart = echarts.init(document.getElementById('main'));
myChart.showLoading();
$.get('cvpr_authors.gexf', function (xml) {
myChart.hideLoading();
var graph = echarts.dataTool.gexf.parse(xml);
var categories = [];
for (var i = 0; i < 30; i++) {
categories[i] = {
name: '' + i
};
}
graph.nodes.forEach(function (node) {
node.itemStyle = null;
node.value = node.symbolSize;
node.symbolSize *= 1;
node.label = {
normal: {
show: node.symbolSize > 30
}
};
node.category = node.attributes.modularity_class;
});
option = {
title: {
text: '作者关系图',
subtext: 'Default layout',
top: 'bottom',
left: 'right'
},
tooltip: {},
legend: [{
data: categories.map(function (a) {
return a.name;
})
}],
animationDuration: 1500,
animationEasingUpdate: 'quinticInOut',
series : [
{
name: '论文数',
type: 'graph',
layout: 'circular',
circular: {
rotateLabel: true
},
data: graph.nodes,
links: graph.links,
categories: categories,
roam: true,
focusNodeAdjacency: true,
itemStyle: {
normal: {
borderColor: '#fff',
borderWidth: 1,
shadowBlur: 10,
shadowColor: 'rgba(0, 0, 0, 0.3)'
}
},
label: {
position: 'right',
formatter: '{b}'
},
lineStyle: {
color: 'source',
curveness: 0.3
},
emphasis: {
lineStyle: {
width: 5
}
}
}
]
};
myChart.setOption(option);
}, 'xml');
</script>
</body>
</html>
效果图如下：
由于作者间关系过于复杂，所有数据生成的图会过密。
筛选部分可得下图：
鼠标移动到某个点上可查看这个作者的论文数及与其他作者的关系：
不足
- 由于没有对原始数据进行清洗，得到的图过于复杂，可能不方便直观的看出作者关系。
- 由于对数据在图上的分布位置没有合理规划，可能会导致部分点重叠或无法看清（还是因为数据未清洗）。
