[TOC]

1、 安装

1

yum install subversion

创建仓库

1
2
3

mkdir /home/svnrepo  #创建仓库目录
svnadmin create /home/svnrepo #指定为代码仓库
cd /home/svnrepo #进入目录

有如下内容：

后续操作的配置文件均在conf目录下。

2、 配置

进入conf目录，查看文件，分别作用如下

1
2
3

authz # 权限配置文件 
passwd  #账号密码配置文件
svnserve.conf  #服务配置文件

2.1 配置用户

1

vim passwd

在[users]下面添加用户，添加格式为 username = password

2.2 配置用户组和权限

1

vim authz

[groups]：为用户分组，根据项目，部门可以进行分组，配置格式如下

groupname = username,username

[仓库路径]: 为仓库路径配置权限，如/是根路径，/project1 是项目1；如若细分可以继续分为项目的某个文件或文件夹。权限如下：

r : 只读

rw：读写

空：不可读不可写

指定用户规则如下：

username：指定某个用户

@groupname : 指定用户组

*：其他用户

2.3 配置svn

1

vim svnserve.conf

打开下面的5个注释

anon-access = read #匿名用户可读
auth-access = write #授权用户可写
password-db = passwd #用户账号文件名
authz-db = authz #权限配置文件名
realm = /home/svnrepo # 仓库所在目录

3、启动停止

1
2

svnserve -d -r /home/svnrepo #启动
killall svnserve #停止

4、客户端连接

客户端使用小乌龟TortoiseSVN连接，连接地址是：svn://ip地址

这里使用admin登陆，因为现在连接的仓库路径默认是/，而配置里面对/的配置权限最大的是admin

5、导入项目

5.1、导入目录项目

• 进入项目所在的目录

• 设置忽略文件，比如Maven生成的target目录不需要上传、本地开发环境的配置。

  鼠标右键“TortoiseSVN”– >“Settings”

  找到General中的”Global ignore pattern”
  添加:target *.settings .classpath .project
  

• 继续右键 –》TortoiseSVN–》Import导入项目到仓库
  

• 确认项目添加的仓库
  
• 然后可以在svn管理中，看到刚刚上传的代码
  

添加版本管理

如果需要继续管理代码版本，则把之前仓库的代码在checkout到当前目录，把原来没有版本控制的文件覆盖掉。

后续有代码变动，只需右键commit即可

5.2、导入IDEA项目

如果是正在开发中的项目，或者是需要一边开发一边提交的情况，可以直接在IDEA添加版本控制。每当代码完成之后便可以提交到仓库中。（多人协同开发记得update再commit，不然会冲突；或者把别人的代码覆盖。

• 将项目分享到SVN
  
• 添加刚刚的仓库地址
  
• 查看这个版本控制选项卡
  
• 需要提交的代码勾选即可
  
• 这里是使用IDEA提交的代码
  

6、总结

1. svn如何配置

   使用svnadmin create 指定仓库路径之后会自动生成一些文件，其中配置文件在conf下。主要有如下配置：

   • 用户配置：passwd文件
   • 权限配置：authz文件
   • 服务配置：svnserve.conf文件

2. 如何将本地项目添加svn管理

   • 文件目录中的代码，先import再checkout
   • idea在VCS中share 到 svn

3. svn作为一个协同开发管理工具，还有很多需要学习的地方，包括版本号管理，发生冲突如何解决，如何进行分支开发等等。

【Linux】CentOS7 下安装Docker 和运行Jar包

1.简介

1.1 是什么？简单来说就是一个轻量型的虚拟机，与虚拟机不同的是Docker容器实现的是软件资源上的虚拟化。而虚拟机是将硬件也进行虚拟化，因此容器比较轻量级，节约资源。

1.2 可以做什么？

1)Web 应用的自动化打包和发布。
2)自动化测试和持续集成、发布。
3）在服务型环境中部署和调整数据库或其他的后台应用。
4）从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。
—–来自菜鸟教程

目前我仅用于web应用部署，希望之后可以有机会进行其他的应用。

1.3 怎么做？看下面

2.安装和配置

2.1 安装docker

安装所需的软件包

1

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

安装成功的话，会有以下输出。

1

xxx already installed and latest version

配置docker的国内镜像源

1

sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

更新缓存

1

sudo yum makecache fast

安装docker-ce

1

sudo yum -y install docker-ce

启动dokcer

1

sudo systemctl start docker

测试运行 hello-world:

1

docker run hello-world  #很慢

2.1 配置docker

docker默认的镜像源于国内而言是有些慢，所以可以配置一下国内的镜像源，提高一下pull速度。
创建目录

1

sudo mkdir -p /etc/docker

创建一个镜像配置文件

1

sudo vim /etc/docker/daemon.json

配置文件中添加镜像

1
2
3

{
 "registry-mirrors":["http://hub-mirror.c.163.com"] 
}

重启docker

1

systemctl restart docker

一些其他的加速站点

1
2
3

https://registry.docker-cn.com
http://hub-mirror.c.163.com
https://mirror.ccs.tencentyun.com

3.基础使用

3.1 Docker 安装Redis

1

docker pull redis:latest

查看当前的镜像

1

docker images

运行redis

1
2
3
4
5
6

docker run -d --name redis-test -p 6379:6379 redis
#-d : 后台运行
#--name : 指定容器的名称
#redis-test : 容器名称
#-p : 指定端口映射，前面的是容器的端口，后面的是系统的端口
#redis : 镜像名称

查看当前运行中的容器

1

docker ps

3.2 Docker 基本概念和命令

• 镜像：运行软件模板，如之前的redis
• 容器：镜像运行之后的实例，如之前的 redis-test

命令：

• docker images：查看本地docker镜像列表
• docker ps : 查看当前运行中的容器实例，可以检查镜像是否运行成功
• docker rm id：删除指定容器
• docker rmi imges-name：删除指定镜像

[TOC]

CentOS7 下 安装JDK与Maven

1.获取压缩包

Maven与Jenkins都需要jdk，所以先安装jdk，同时maven与jdk安装步骤大致相同，可以同时操作
1.使用ftp传输JDK安装包到linux上 某云下载提取码：hm6u

2.wget方式获取

以下是jdk的

1

wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u141-b15/336fa29ff2bb4ef291e347e091f7f4a7/jdk-8u141-linux-x64.tar.gz"

2.解压

1.使用tar -zxvf 解压jdk与maven的压缩文件 。输入命令之后，再输入文件名的前面几个字母可以按tab补全；分别解压之后会产生两个文件夹。

使用mv命令移动这两个文件夹到指定目录,方便后续配置

1
2
3

mv apache-maven-3.6.3 /usr/local/maven

mv jdk1.8.0_221 /usr/local/jdk8

移动完成之后，可以分别进入查看是否移动了正确的文件

3. 配置环境变量

1

vim /etc/profile

在文件的最后添加上

1
2
3

export JAVA_HOME=/usr/local/jdk8 # 刚刚jdk移动到的目录
export MAVEN_HOME=/usr/local/maven # 刚刚maven移动到的目录
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$MAVEN_HOME/bin:$PATH

最后使用以下命令使配置生效

1

source /etc/profile

最后检查是否生效

1
2
3

java -version #检查jdk是否安装成功

mvn -v #检查maven是否安装成功

maven成功

4.问题

一开始运行java -version的时候报错如下

1
2

[root@instance-7k1d5qb8 bin]# java -version
-bash: /usr/local/maven/bin/java: /lib/ld-linux.so.2: bad ELF interpreter: No such file or directory

度娘了一圈，大意是由于系统位数差异，缺少了东西。找到如下解决方法

1

yum install glibc.i686

5. 总结

1.安装流程如下：获取压缩包-》解压指定文件位置-》配置环境变量-》刷新环境变量

2.还有一种安装方法是通过yum源来安装，相当于在windows下的自动安装，如果不熟悉不太方便掌握文件位置

3.本篇基于百度云服务器纯净的Centos版本，为后续Jenkins安装部署做铺垫

[TOC]

一、Jenkins介绍

来自官网 的介绍：

作为一个可扩展的自动化服务器，Jenkins 可以用作简单的 CI 服务器，或者变成任何项目的持续交付中心。

我的理解：

可以将代码从SVN或GIT仓库拉取过来进行自动编译与发布，所以可以成为一个交付中心，也可以作为一个集成测试环境。

二、前置准备

2.1服务器(Linux)所需环境

1
2
3
4
5
6
7

OS：CentOS7 （买的百度云学生服务器
Jenkins
Docker
Jdk
Maven
SVN
Git(从github拉取代码所需)

Jdk&Maven安装点这
Docker 安装点这
SVN 安装使用点这

2.2配置Docker工作空间

1
2
3
4
5

#创建文件夹用来放docker工作空间
mkdir /home/work/demo
cd /home/work/demo
#创建备份文件夹
mkdir backup

然后添加Docker构造文件

1

vim Dockerfile

在文件中添加如下内容

1
2
3
4
5
6
7

#基于openjdk:8
FROM openjdk:8
#这里其他的项目，可以把demo改成其他的项目名称
ADD demo-1.0-SNAPSHOT.jar demo.jar
RUN bash -c 'touch /demo.jar'

ENTRYPOINT ["java","-jar","/demo.jar"]

添加shell脚本文件

1

vim run.sh

添加如下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#定义好这些变量，后面其他的项目，只需要改前面这些变量即可
PROJECT_NAME=JenkinsDemo #Maven项目名称
IMAGE_NAME=demo  #生成的镜像名称
BASE_PATH=/home/work/demo #Docker工作空间
PORT=9120 #端口
TASK_NAME=Jenkins # 任务名称
SOURCE_PATH=/var/lib/jenkins/workspace/$TASK_NAME/target/ # Jenkins生成jar包位置
#查看当前docker是否运行了该项目
CID=$(docker ps | grep "$IMAGE_NAME" | awk '{print $1}')
 
DATE=`date +%Y%m%d%H%M`
 
# 将jar包移动到工作空间
function transfer(){
    echo "newest $SOURCE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar moveto $BASE_PATH ...."
        sudo cp $SOURCE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar $BASE_PATH/$IMAGE_NAME-1.0-SNAPSHOT.jar
    echo "move complete"
}
 
# 备份
function backup(){
        if [ -f "$BASE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar" ]; then
        echo "$PROJECT_NAME-1.0-SNAPSHOT.jar 开始备份"
                sudo cp $BASE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar $BASE_PATH/backup/$PROJECT_NAME-$DATE.jar
                        sleep 3
                        sudo rm -rf $BASE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar
        echo "备份完成"
    else
        echo "$BASE_PATH/$PROJECT_NAME-1.0-SNAPSHOT.jar not exists , pass "
    fi
}
 
#构建镜像
function build(){
        echo "开始构建"
        cd $BASE_PATH
        sudo docker build -t $IMAGE_NAME .
}
 
#运行
function run(){
        backup
        transfer
        build
        if [ -n "$CID" ]; then
                echo "存在，删除再运行"
                        sudo docker stop $CID
                        sudo docker rm $CID
                        sudo docker run -d -p $PORT:$PORT $IMAGE_NAME
                echo "complete"
        else
                echo "不存在，直接运行"
                        sudo docker run -d -p $PORT:$PORT $IMAGE_NAME 
                echo "create ok"
        fi
}
 
#执行run方法
run

三、 安装Jenkins

3.1 官网安装步骤如下：

1
2
3
4
5
6
7
8

#添加jenkins 源
sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo

#导入key
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

#安装
yum install jenkins

不过通过yum安装的效果会比较慢，极端前端下仅几k的速度，因此可以把rpm包先下过来，然后通过rpm的方式安装

3.2 rpm方式安装如下：

• 首先下载rpm包，可从清华镜像下载,也可以从某云提取码w6tl下载
• 将rpm包上传至centos 中
• 执行rpm -ivh jenkins-2.204.2-1.1.noarch.rpm 这个文件

3.3 启动jenkins

1

service jenkins start

如果是自己安装的jdk，Jenkins第一次启动可能会报错，可以使用命令systemctl status jenkins.server来查看错误明细，可以看到错误信息提示java: no such file or directory

执行如下命令：vim /etc/init.d/jenkins

在candidates里面加上自己安装的jdk的java命令的位置，如下

然后重新加载配置文件systemctl daemon-reload后重启Jenkins

1

service jenkins start

成功执行有如下提示

1
2

[root@instance-7k1d5qb8 ~]# service jenkins start 
Starting jenkins (via systemctl):  [  OK  ]

四、 访问Jenkins

在浏览器打开地址http://服务器ip:8080 ，不出意外就能进入到如下界面，然后根据提示输入密码：

输入密码之后会进入到如下界面，选择推荐的插件即可，就会进入到插件安装页面。

如若网络不好的情况下，可能会出现如下情况，安装插件失败

• 解决方法（1）如下

打开 http://ip:8080/pluginManager/advanced

最后站点设置

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

然后保存

• 解决方法（2）如下

  1	vim /var/lib/jenkins/hudson.model.UpdateCenter.xml

  将 https://updates.jenkins.io/update-center.json" 修改为

  “http://mirror.xmission.com/jenkins/updates/update-center.json"

然后systemctl daemon-reload 使配置生效，并重启Jenkins systemctl restart jenkins

访问Jenkins出现的问题：

可能是由于自己按照的jdk，少了一些基础程序，如下安装，重启即可：

1

sudo yum install libgcc.i686 --setopt=protected_multilib=false

五、配置Jenkins

插件安装成功之后会进入到如下界面，创建一个用户即可

使用账号密码登陆之后需要进行一些基础配置：

选择全局工具配置

此处主要配置maven、jdk、docker 三者配置相似，把自动安装的勾取消，便可以输入在系统中的位置。查看环境变量中位置如下：

而yum所安装的docker 位置如下：

1

/var/lib/docker

六、创建SpringBoot项目

新建一个maven项目，项目名为JenkinsDemo 项目名在后续会用到

pom依赖和插件如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<parent>
      <artifactId>spring-boot-parent</artifactId>
      <groupId>org.springframework.boot</groupId>
      <version>2.1.7.RELEASE</version>
</parent>
  
<dependencies>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
  </dependencies>


  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
              <version>2.1.7.RELEASE</version>
              <executions>
                  <execution>
                      <goals>
                          <goal>repackage</goal>
                      </goals>
                  </execution>
              </executions>
              <configuration>
                  <fork>true</fork>
              </configuration>
          </plugin>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.1</version>
              <configuration>
                  <source>1.8</source>
                  <target>1.8</target>
              </configuration>
          </plugin>
      </plugins>
  </build>

application.yml 修改端口，默认8080会和Jenkins冲突，除非修改了Jenkins的端口

1
2

server:
  port: 9120

Controller类

1
2
3
4
5
6
7
8
9

@RestController
public class HelloController {

    @RequestMapping("/test")
    public String hello(){
        return "自动构建测试" + LocalDateTime.now();
    }

}

启动类

1
2
3
4
5
6

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args);
    }
}

项目基础结构搭建完成之后。

6.1 添加SVN控制

添加完版本控制之后，底端会有一个Version Control ，右键选择commit

勾选需要提交的文件夹或文件

提交完成之后，可以在svn管理软件中看到，此处使用小乌龟

七、新建任务

输入名称Jenkins，选择构建一个自由风格的软件项目 确定，便进入到如下配置

勾选这个，以免产生过多的文件，导致服务器资源耗竭

添加svn，Jenkins会从这获取源码

svn当然需要添加账号密码

触发器，大概就是何时会进行构建，如若是变化不频繁的，可以不选，手动构建

这里仍然是删除之前的工作空间，避免代码冲突

因为我们的是Maven项目，所以选择Maven构建

Maven构建配置如上。配置文件也可以指定位置，最好指定修改了国内镜像的settings.xml 文件

后面选择执行shell脚本

1
2
3
4

#!/bin/bash
cd /home/work/demo

sudo ./run.sh

最后确定

7.1 构建查看输出

项目构建成功首页如下所示，点击名称Jenkins查看该任务详情

里面的工作空间存放了从svn拉取的代码，下面的Build History 就是每次构建的记录

这里是看工作空间的代码

点击Build History里面的某一项记录，可以进入到这里，然后点击控制台输出可以查看代码运行情况。

第一次运行输出往往会需要从maven下载各种依赖，如果比较慢的话，是否需要切换为国内镜像。

下图的红圈中，

第一部分表示Maven install 已经ok了 ；

第二部分是开始执行shell命令 ；

第三部分是执行Dockerfile 命令。

如果在那个部分出了问题导致访问失败，可以对应排除。

如果一路顺利，⑧出意外的话，执行

1

docker ps

便可以看到如下输出，表示该demo已经运行完成。

然后我们只需要在浏览器输入

1

http://ip:9120/test

便可以看到如下输出。然事与愿违，这个过程构建了好几次才搞定。后面有参考

7.2 构建遇见的问题

1. sudo: ./run.sh: command not found ，因为刚刚创建的run.sh文件没有赋予可执行权限

   ​ 在/home/work/demo 目录下执行如下命令

   1	chmod a+x run.sh

   

2. 各种no such directory , 根据控制台输出提示的部分，然后查看是哪个文件配置出错，然后处理

3. sudo: no tty present and no askpass program specified 因为在shell文件中有sudo命令，但是权限又不够。

   1 2 3 4 5 6 7 8 9 10

   #在Jenkins宿主服务器上运行如下命令 $ sudo visudo #在文件的末尾加上一行 jenkins ALL=(ALL) NOPASSWD: ALL #保存文件（注意保存的时候修改文件名，文件名后缀不要加上默认的.tmp，即可覆盖原文件） Ctrl+O #退出编辑 Ctrl+X #重启Jenkins服务 /etc/init.d/jenkins restart

4. Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?

   ​ 重启docker 即可 systemctl restart docker

八、更新迭代

在Controller中添加如下代码：

1
2
3
4

@GetMapping("/new")
  public String newMethod(){
       return "version 2";
}

然后提交到svn

稍等一会待Jenkins自动构建

然后在浏览器地址中输入http://ip:9120/new,不出意外便能出现一下结果。如果无：

1. 查看是否产生了构建，若无，点击立即构建手动
2. 查看构建记录中的控制台输出，根据不同的提示，解决不同的问题。

九、总结

这仅是Jenkins的简单使用，还有更过的高级用法暂未用到，学习记录倒是够了。

1.这里用Jenkins做了什么？

​ 本地敲代码 -》 提交到SVN -》 Jenkins自动编译部署 -》访问网页

2.Jenkins几个配置

​ 全局配置: Jdk、Maven、Docker

​ 任务配置: 代码源，如何构建

1.项目环境

基于 Python3.7 ，使用 Scrapy框架，正常抓取某网站搜索指数排名。

2.需求背景

由于网络时好时坏，有时候会遇到timeout这种延时错误，出错之后爬虫便会停止，如果没有第一时间重启，或者是排错，抓取效率便会十分低下。所以便想着有没有解决方法（爬虫项目是同事写的，跑在我电脑上，实习生打杂就完事了

3.解决思路

• 1.利用另外一个Python程序，监控该爬虫进程是否正常进行，同理也可以扩展到监控其他的程序是否正常运行。

  • 2.利用Scrapy框架自身提供的中间件进行错误处理

3.1 进程监控

实现进程监控需要解决以下问题

1. 如何用python获取电脑中运行的进程？

2. 如何知道要监控的进程是否存活？

   第一个问题使用python提供的os库可以解决

1

os.popen('tasklist')

tasklist ： 输出电脑上当前所执行的程序名已经进程编号PID

该方法类似与在cmd命令行下所执行的效果一样，会将在cmd下执行的结果输出到缓冲流，因此我们也需要从缓冲流中把结果读出来。

1

os.popen('tasklist').read()

第二个问题，我们可以使用新建子进程来解决这个问题

1
2
3
4
5
6
7
8
9
10

from multiprocessing import Process
from  scrapy  import cmdline

def execute_spider()
	cmdline.execute('scrapy crawl my_spider'.split())

my_pro = Process(target=executeSpider)
my_pro.start()
print("pid:%s  =" % my_pro.getpid())
# 在这里可以获得pid,可以使用进程通信方式把pid传递过去，我比较简单，使用的文件存储pid，监控程序读文件就好了

在这里使用getpid()便可以获得该爬虫的进程号，结合之前的命令，便可以知道当前程序是否正常运行。

1
2

# 从tasklist的输出中，统计该pid的数量，从而判定该进程是否存在
 isAlive = os.popen('tasklist').read().count(pid) != 0

3.2 Scrapy中间件之异常处理

在Scrapy中存在两种中间件，一种是SpiderMiddleWare（蜘蛛中间件），一种是DownloaderMiddlerWare（下载器中间件）。

• 蜘蛛中间件： Scrapy中Engine组件与Spider交互经过的中间件，如果蜘蛛发生的异常，就在这个里面处理，比如在解析数据的时候发生的错误。对应的方法如下：

1
2
3
4
5
6
7
8

 """
response: 异常被抛出时被处理的response对象 
exception: 抛出的异常 
spider: 抛出该异常的spider对象 
""" 
def process_spider_exception(self, response, exception, spider): 
	# 相应处理
	pass

• 下载器中间件：Scrapy中Engine组件与Downloader交互经过的中间件，这个处理的错误一般都是网络问题，或者服务器问题。与自己敲的蜘蛛代码关系不大。（我选的这个

  1 2 3 4 5 6 7 8

  """ request: 产生异常的request对象 exception: 抛出的异常对象 spider: 产生异常的request对象的spider对象 """ def process_exception(self, request, exception, spider): # 相应处理 pass

如果使用中间件，别忘记在setting.py文件中开启中间件

1
2
3

DOWNLOADER_MIDDLEWARES = {
  'MySpider.middlewares.MyDownloaderMiddleware': 543,
}

or 蜘蛛中间件

1
2
3

SPIDER_MIDDLEWARES = {
  'MySpider.middlewares.MySpiderMiddleware': 543,
}

4.相应处理

现在已经知道进程是否正常、爬虫出错在哪处理。那么如何处理呢？

4.1 继续运行

第一种继续运行的方式，可以使用死循环，也可以使用调度任务。
死循环实现比较简单，在同一个代码中，开启一个进程执行Scrapy爬虫，一个进程实现监控。（不推荐）

1
2
3
4
5
6
7
8
9
10
11
12
13

#偷懒使用死循环的方式
 while True:
        p = os.popen('tasklist')
        pid = getPid() # 写个读文件的方法
        isAlive = p.read().count(pid) != 0
        count = count +1
        print( "%s  %s 次是 %s" %(datetime.datetime.now(),count,isAlive) )
        if(isAlive==False):
            my_pro = Process(target=executeSpider)
			my_pro.start()
			with open("pid.txt","w") as f:
				f.write(my_pro.getpid())
        time.sleep(60)

第二种利用中间件返回Request让爬虫继续执行：

1
2
3
4
5

def process_exception(self, request, exception, spider): 
with open("exceptionLog.txt", "a") as f:
           msg = "%s : %s\n" %(datetime.datetime.now(),exception)
           f.write(msg) #手动记录日志
return request

4.2 通知

第一种使用窗口弹出，适合在电脑工作时跑的爬虫，这个窗口提醒会置顶，达到提醒的目的，同时程序也会阻塞，需要确认之后才会继续，当然如果有异常的话，也不需要继续了（不适合打游戏时开
需要安装win32库： pip install pywin32

1

win32api.MessageBox(0, "爬虫进程异常，请查看", "提醒", win32con.MB_SYSTEMMODAL)

第二种使用邮件通知，适合不在电脑目前时跑的爬虫。
（这个参考下一篇博文，封装一个发邮件的类，调用一下便ok。

5. 总结

使用一个工具需要慢慢的熟悉，第一个监控进程的方法是在没有弄清有两个中间件导致一直没找到解决方法所想的（囫囵吞枣学了一下Scapy。使用弹窗提醒还可以，同时也可以使用在其他可以在命令行所运行的程序上，见参考博客

借鉴博客如下
https://www.jb51.net/article/163273.htm
https://blog.csdn.net/weixin_41990342/article/details/81907263

Ubuntu系统安装和设置（资源整合）

出于需要，安装一个Ubuntu的虚拟机，期间也是各种问题和麻烦（基本上是后续弄自己的东西的问题。前期安装大概用到了一下的帖子，我只是资源的搬运工。（侵删

下载

推荐国内镜像（阿里）
http://mirrors.aliyun.com/ubuntu-releases/14.04/
http://mirrors.aliyun.com/ubuntu-releases/16.04/
http://mirrors.aliyun.com/ubuntu-releases/18.04/

这里有一个桌面版和服务器版。区别在于：

桌面版： 有界面，内置功能少，需要自己安装

服务器版： 无界面，集成服务器所需大部门功能

安装

https://blog.csdn.net/qq1326702940/article/details/82322079

基础设置

安装vmtool

https://jingyan.baidu.com/article/6fb756ec4079cf241858fba9.html

1. 在VMware上点了按照VMtools之后不用管，之后会自动弹出来
2. 运行是 sudo ./vmware-install.pl 直接点没用

配置网络

https://blog.csdn.net/qi_yue_yu/article/details/52694252

设置apt-get源

默认使用国外的源，速度会慢到令人发指。

https://blog.csdn.net/zgljl2012/article/details/79065174
1.在输入镜像地址那里，可以用到VMtools 的复制粘贴功能
2.我的没有gedit命令，就使用了vi，但是退格键有时候会失灵。
https://blog.csdn.net/kang123488/article/details/79512721（第一个方法）

安装SSH并用Xshell等工具连接

使用CentOS的习惯，还可以通过这个传文件

https://jingyan.baidu.com/article/54b6b9c08ff5c42d583b473c.html

其他问题

过程可以会遇到其他问题，一般用错误提示的组后那一段字去百度，都有相应的解决方法

在线投票

在线投票系统，用户注册成为网站会员之后在系统中发起投票和进行投票，其次可以根据用户自己输入的信息分析用户行为和占比。主要用于人物评选，市场用户喜好分析。

项目功能概述

投票包含投票标题，类型（单选或多选），开始时间和结束时间，已经投票选项。普通用户可以在系统查看别人发起的投票进行投票，也可以维护自己发起投票，比如修改和删除，完成投票或者投票结束之后就可以查看投票结果。管理员可以管理所有用户，升级权限或者禁用账号，对所有投票进行查看和删除。

技术选型

基于JavaWeb,采用Mysql存储数据，使用nginx作为图片服务器进行图片代理。html/js/css/jquery，bootstrap 等前端技术。

前后端接口交互设计

混用jquery 和 jstl/el表达式进行页面渲染，因此在servlet里面有两种返回方式，一种是页面跳转，一种是内容输出。内容输出对应的ajax请求，请求转发采用jstl与el表达式渲染。前期确定好交互的接口，和servlet是有必要的，可以有效进行拦截权限控制。

数据库方面

优化到第三范式，单表信息存储对象内容，也就是将java的面向对象转成关系型表示。采用主外键连接彼此的依赖关系。

项目展示

更多也面就不截图了。

心得总结

通过这次实训，又积累了一个项目经验，了解了一个业务的流程。这次项目还是不够完善，存在架构和耦合方面的问题，感觉代码并不易于理解，发现自己的缺点也是自己以后前进的方向。这次项目的遗憾有以下几点。首先前期需求不够完善，仅仅是局部的内容。因此设计上受到了局限性，给后期业务带来些许麻烦。其次主要的弱点和不足均表现在前端，前后端交互原本是数据的交换，后端提供一个数据接口，将前端提供的数据加工之后再返回的过程。数据的交互不要求页面，也不顾及用户体验。但是前端是用户和系统的桥梁，如果这座桥梁不够美观和牢固，自然也没有用户会使用这个系统。虽然主要是走后端，但是对前端知识的匮乏也可能会成为后期发展的桎梏。

深度剖析Spring（一） 体系结构

前言

Spring作为一个轻量级的Java开发框架，简化了Java应用开发的复杂性，减少了代码的耦合度。不过在初次接触Spring的时候，对于各种配置文件，还是有点头疼，甚至觉得复杂化了开发过程。不过在学到后面的时候，发现Spring还是挺好用的。Spring同时也是一个工具，一个大部分开发者都喜欢的工具。所以在掌握其使用方法的同时，了解其设计理念，其源码实现，对于开发也是有好处的。

前言

动态规划在《数据结构与算法》中接触过，随后在《软件设计师教程》中也学习过，每次学完没有做记录，感觉会了，但实际上还是有些不理解的。这次在《图解算法》中重新接触到动态规划，讲得挺透彻的，应该要好好记录下来。无论动态规划的问题有多么形式多样，只要了解了解题思路和原理。再多加练习，肯定能掌握的。

基本思想

其基本思想是将待求解的问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

这是《软件设计师教程》中对动态规划思想的描述。看起来很简单，就把大问题划成小问题。恰恰难的也就是如何将大问题化解成小问题。通过这篇文章，来慢慢体会这个划分的过程。

SpringMVC 拦截器浅析与实例

拦截器的作用，类似于传统servlet的过滤器Filter，在执行请求时，做出预处理，与后处理。不过拦截器中，还有一个中处理（暂且这么称呼）。过滤器我们通常用来执行权限验证，统计访问，计算处理时间等等。拦截器也一样，下面先看看DispatchServlet中拦截器的参与过程。