SpringBoot整合Redis和StringRedisTemplate的使用

 spring, spring-boot  SpringBoot整合Redis和StringRedisTemplate的使用已关闭评论
1月 212019
 

springboot下使用redis非常方便:


Maven依赖

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-redis</artifactId>

    <!– <artifactId>spring-boot-starter-redis</artifactId> –>    

</dependency>

 

配置文件 application.properties添加

#redis的ip地址 

spring.redis.hostName=127.0.0.1

#数据库,默认为0

spring.redis.database=1

#端口号 

spring.redis.port=6379

#如果有密码 

spring.redis.password=xxxxx

#客户端超时时间单位是毫秒 默认是2000

spring.redis.timeout=20000 

 

StringRedisTemplate使用

stringRedisTemplate.opsForValue();//操作字符串

stringRedisTemplate.opsForHash();//操作hash

stringRedisTemplate.opsForList();//操作list

stringRedisTemplate.opsForSet();//操作set

stringRedisTemplate.opsForZSet();//操作有序set

示例

import
org.springframework.beans.factory.annotation.Autowired;

import
org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.stereotype.Service;

 

import java.util.concurrent.TimeUnit;

 

@Service

public class RedisService {

    @Autowired

   
StringRedisTemplate stringRedisTemplate;

 

    /**

     *
stringRedisTemplate基本操作

     */

    public void redis(){

       
stringRedisTemplate.opsForValue().set(“key”, “value”,60*10,
TimeUnit.SECONDS);//向redis里存入数据和设置缓存时间(10分钟)

       
stringRedisTemplate.boundValueOps(“key”).increment(1);//val做1操作

       
stringRedisTemplate.opsForValue().get(“key”);//根据key获取缓存中的val

       
stringRedisTemplate.boundValueOps(“key”).increment(1);//val +1

       
stringRedisTemplate.getExpire(“key”);//根据key获取过期时间

       
stringRedisTemplate.getExpire(“key”,TimeUnit.SECONDS);//根据key获取过期时间并换算成指定单位

       
stringRedisTemplate.delete(“key”);//根据key删除缓存

       
stringRedisTemplate.hasKey(“key”);//检查key是否存在,返回boolean

       
stringRedisTemplate.opsForSet().add(“key”, “5”,”6″,”7″);//向指定key中存放set集合

       
stringRedisTemplate.expire(“key”,1000 ,
TimeUnit.MILLISECONDS);//设置过期时间

       
stringRedisTemplate.opsForSet().isMember(“key”, “1”);//根据key查看集合中是否存在指定数据

       
stringRedisTemplate.opsForSet().members(“key”);//根据key获取set集合

 

    }

}

 

 

ffmpeg常用使用场景及命令

 ffmpeg  ffmpeg常用使用场景及命令已关闭评论
1月 102019
 

网上收集的ffmpeg常用使用场景及命令使用:

应用场景1:格式转换

我想把用iPhone拍的.MOV文件转成.avi文件。最简单了,可以执行下面的命令:

ffmpeg -i D:\Media\IMG_0873.MOV D:\Media\output.avi

意思是,把D:\Media目录下的源文件IMG_0873.MOV(视频:h.264,音频:aac)转换成output.avi(编码格式自动选择为:视频mpeg4,音频mp3),目标文件仍然保存到D:\Media目录下。问题来了:我想自己指定编码格式,怎么办呢?一种方法是,通过目标文件的扩展名(.flv、.mpg、.mp4、.wmv等)来控制,比如:

ffmpeg -i D:\Media\IMG_0873.MOV D:\Media\output2.flv

另一种方法是通过-c:v参数来控制,比如我想输出的视频格式是H.265(警告:编码时间会比较长哦)。命令行如下:

ffmpeg -i D:\Media\IMG_0873.MOV -c:v libx265 D:\Media\output265.avi

注:可以先用ffmpeg -encoders命令查看一下所有可选的编码格式。

不再深究了,我们继续。我发现源文件的图像帧尺寸是1920x 1080,我不需要这么大——能有720 x 480就够了。于是,就要用上-s参数了。为了保证图像缩放后的质量,最好加上码率参数-b:v。如下:

ffmpeg -i D:\Media\IMG_0873.MOV -s 720×480 -b:v 1500k D:\Media\output2.avi

还可以更简单一点,使用-target参数匹配行业标准,参数值可以是vcd、svcd、dvd、dv、dv50等,可能还需要加上电视制式作为前缀(pal-、ntsc-或film-)。如下:

ffmpeg -i D:\Media\IMG_0873.MOV -target pal-dvd D:\Media\output2dvd.avi

又来一个问题:我发现用手机拍的视频中,有些是颠倒的,我想让它顺时针旋转90度。这时候,可以使用-vf参数加入一个过滤器,如下:

ffmpeg -i D:\Media\IMG_0873.MOV -vf “rotate=90*PI/180” D:\Media\output3.avi

注:如果想逆时针旋转90度,90前面加个负号就可以了。

如果我只需要从源视频里截取一小段,怎么办呢?比如从第2秒的地方开始,往后截取10秒钟。命令行可以这样:

ffmpeg -ss 2 -t 10 -i D:\Media\IMG_0873.MOV D:\Media\output4.avi

注:这种情况下,-ss和-t参数必须放在-i前面,表示是限定后面跟着的输入文件的。

应用场景2:视频合成

我发现,用手机拍的视频有时候背景噪音比较大。怎么把噪音去掉,换成一段美妙的音乐呢?使用FFmpeg也能轻易做到。

第一步:把源文件里的音频去掉,生成一个临时文件tmp.mov

ffmpeg -i D:\Media\IMG_0873.MOV -vcodec copy -an D:\Media\tmp.mov

注:-vcodeccopy的意思是对源视频不解码,直接拷贝到目标文件;-an的意思是将源文件里的音频丢弃。

第二步:把这个无声的视频文件(tmp.mov)与一个音乐文件(music.mp3)合成,最终生成output.mov

ffmpeg -i D:\Media\tmp.mov -ss 30 -t 52 -i D:\Media\music.mp3 -vcodec copy D:\Media\output5.avi

为了保证良好的合成效果,音乐时长必须匹配视频时长。这里我们事先知道视频时长为52秒,于是截取music.mp3文件的第30秒往后的52秒与视频合成。另外,为了保证音频时长截取的准确性,我们这里没有使用-acodec copy,而是让音频重新转码。

还有一种情况:我们希望在一段视频上叠加一张图片。可以简单实现如下:

ffmpeg -i D:\Media\IMG_0873.MOV -i D:\Media\logo.png -filter_complex ‘overlay’ D:\Media\output6.avi

应用场景3:视频播放

格式转换或合成之后,我们需要试着播放一下。播放器的选择很多。这里顺手用ffplay工具也行:

ffplay -i D:\Media\output6.avi

应用场景4:获取视频信息

有时候,我只是想看看这个视频文件的格式信息。可以用ffprobe工具:

ffprobe -i D:\Media\IMG_0873.MOV

应用场景5: 截取视频片段转为GIF动画

可以简单地执行下面的命令行:

ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -f gif D:\a.gif

意思是:将D:\Media目录下的源文件bear.wmv,从第25秒的位置开始,截取10秒长度的视频转成GIF文件,保存为D:\a.gif。

想要知道FFmpeg到底支持哪些格式吗?执行ffmpeg –formats即可。

问题来了,你的源文件可能是1080P的高清视频,帧率可能还比较高。为了便于网络分享,GIF文件最好小一点。于是,我们需要使用-s参数来进行图像的缩放,使用-r参数来限制目标文件的帧率。命令行如下:

ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -s 320×240 -f gif -r 1 D:\b.gif

把b.gif拖进浏览器预览,结果发现:虽然帧率降到了1 fps(从源视频里每隔一秒抽取一帧图像输出到目标文件),整个动画播放还是持续了10秒钟,看着很揪心!能不能在源视频跳帧的情况下同时提高GIF的播放速率呢(比如说在2秒内播完)?查了一遍FFmpeg的说明文档,似乎没有哪个参数可以快速达到这样的目的。也罢,那就分两步走吧:

首先,执行ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -r 1 -s 320×240 -f image2 D:\foo-%03d.jpeg,从源视频中每秒钟抽取一帧图像,保存为一系列JPEG文件。然后,再执行ffmpeg -f image2 -framerate 5 -i D:\foo-%03d.jpeg D:\c.gif,将这一系列JPEG图像合成为帧率5 fps的GIF文件。Bingo!

上面提到,把GIF文件拖进浏览器可以进行预览。当然,使用ffplay.exe工具也是可以的——命令行:ffplay D:\a.gif。

p.s. 附送一条指令:截取视频内任意时间点(比如第16.1秒处)的一帧图像保存为JPEG文件:ffmpeg -ss 16.1 -i D:\Media\bear.wmv -s 320×240 -vframes 1 -f image2 D:\d.jpeg

其他应用

FFmpeg的功能非常强大。关键是要理解各种参数的意义,并且巧妙搭配。必要的话,就把在线文档完整读一遍吧:http://www.ffmpeg.org/ffmpeg.html

================ffmpeg 常用基本命令=========================

1.分离视频音频流

ffmpeg -i input_file -vcodec copy -an output_file_video //分离视频流 ffmpeg -i input_file -acodec copy -vn output_file_audio //分离音频流

2.视频解复用

ffmpeg –i test.mp4 –vcodec copy –an –f m4v test.264ffmpeg –i test.avi –vcodec copy –an –f m4v test.264

3.视频转码

ffmpeg –i test.mp4 –vcodec h264 –s 352*278 –an –f m4v test.264              //转码为码流原始文件 ffmpeg –i test.mp4 –vcodec h264 –bf 0 –g 25 –s 352*278 –an –f m4v test.264  //转码为码流原始文件 ffmpeg –i test.avi -vcodec mpeg4 –vtag xvid –qsame test_xvid.avi            //转码为封装文件//-bf B帧数目控制,-g 关键帧间隔控制,-s 分辨率控制

4.视频封装

ffmpeg –i video_file –i audio_file –vcodec copy –acodec copy output_file

5.视频剪切

ffmpeg –i test.avi –r 1 –f image2 image-%3d.jpeg        //提取图片 ffmpeg -ss 0:1:30 -t 0:0:20 -i input.avi -vcodec copy -acodec copy output.avi    //剪切视频//-r 提取图像的频率,-ss 开始时间,-t 持续时间

6.视频录制

ffmpeg –i rtsp://192.168.3.205:5555/test –vcodec copy out.avi

7.YUV序列播放

ffplay -f rawvideo -video_size 1920x1080 input.yuv

8.YUV序列转AVI

ffmpeg –s w*h –pix_fmt yuv420p –i input.yuv –vcodec mpeg4 output.avi

常用参数说明:

主要参数: -i 设定输入流 -f 设定输出格式 -ss 开始时间 视频参数: -b 设定视频流量,默认为200Kbit/s -r 设定帧速率,默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器,未设定时则使用与输入流相同的编解码器 音频参数: -ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器,未设定时则使用与输入流相同的编解码器 -an 不处理音频

——————————————————————————————–

——————————————————————————————–

1、将文件当做直播送至live

ffmpeg -re -i localFile.mp4 -c copy -f flv rtmp://server/live/streamName

2、将直播媒体保存至本地文件

 

ffmpeg -i rtmp://server/live/streamName -c copy dump.flv

3、将其中一个直播流,视频改用h264压缩,音频不变,送至另外一个直播服务流

 

ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv rtmp://server/live/h264Stream

 

4、将其中一个直播流,视频改用h264压缩,音频改用faac压缩,送至另外一个直播服务流

ffmpeg -i rtmp://server/live/originalStream -c:a libfaac -ar 44100 -ab 48k -c:v libx264 -vpre slow -vpre baseline -f flv rtmp://server/live/h264Stream

5、将其中一个直播流,视频不变,音频改用faac压缩,送至另外一个直播服务流

ffmpeg -i rtmp://server/live/originalStream -acodec libfaac -ar 44100 -ab 48k -vcodec copy -f flv rtmp://server/live/h264_AAC_Stream

6、将一个高清流,复制为几个不同视频清晰度的流重新发布,其中音频不变

ffmpeg -re -i rtmp://server/live/high_FMLE_stream -acodec copy -vcodec x264lib -s 640×360 -b 500k -vpre medium -vpre baseline rtmp://server/live/baseline_500k -acodec copy -vcodec x264lib -s 480×272 -b 300k -vpre medium -vpre baseline rtmp://server/live/baseline_300k -acodec copy -vcodec x264lib -s 320×200 -b 150k -vpre medium -vpre baseline rtmp://server/live/baseline_150k -acodec libfaac -vn -ab 48k rtmp://server/live/audio_only_AAC_48k

7、功能一样,只是采用-x264opts选项

ffmpeg -re -i rtmp://server/live/high_FMLE_stream -c:a copy -c:v x264lib -s 640×360 -x264opts bitrate=500:profile=baseline:preset=slow rtmp://server/live/baseline_500k -c:a copy -c:v x264lib -s 480×272 -x264opts bitrate=300:profile=baseline:preset=slow rtmp://server/live/baseline_300k -c:a copy -c:v x264lib -s 320×200 -x264opts bitrate=150:profile=baseline:preset=slow rtmp://server/live/baseline_150k -c:a libfaac -vn -b:a 48k rtmp://server/live/audio_only_AAC_48k

8、将当前摄像头及音频通过DSSHOW采集,视频h264、音频faac压缩后发布

ffmpeg -r 25 -f dshow -s 640×480 -i video=”video source name”:audio=”audio source name” -vcodec libx264 -b 600k -vpre slow -acodec libfaac -ab 128k -f flv rtmp://server/application/stream_name

9、将一个JPG图片经过h264压缩循环输出为mp4视频

ffmpeg.exe -i INPUT.jpg -an -vcodec libx264 -coder 1 -flags +loop -cmp +chroma -subq 10 -qcomp 0.6 -qmin 10 -qmax 51 -qdiff 4 -flags2 +dct8x8 -trellis 2 -partitions +parti8x8+parti4x4 -crf 24 -threads 0 -r 25 -g 25 -y OUTPUT.mp4

10、将普通流视频改用h264压缩,音频不变,送至高清流服务(新版本FMS live=1)

ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv “rtmp://server/live/h264Stream live=1〃

————————————————————————

————————————————————————

1.采集usb摄像头视频命令:

ffmpeg -t 20 -f vfwcap -i 0 -r 8 -f mp4 cap1111.mp4

 

./ffmpeg -t 10 -f vfwcap -i 0 -r 8 -f mp4 cap.mp4

具体说明如下:我们采集10秒,采集设备为vfwcap类型设备,第0个vfwcap采集设备(如果系统有多个vfw的视频采集设备,可以通过-i num来选择),每秒8帧,输出方式为文件,格式为mp4。

 

2.最简单的抓屏:

ffmpeg -f gdigrab -i desktop out.mpg 

 

3.从屏幕的(10,20)点处开始,抓取640×480的屏幕,设定帧率为5 :

ffmpeg -f gdigrab -framerate 5 -offset_x 10 -offset_y 20 -video_size 640×480 -i desktop out.mpg 

 

4.ffmpeg从视频中生成gif图片:

ffmpeg -i capx.mp4 -t 10 -s 320×240 -pix_fmt rgb24 jidu1.gif

 

5.ffmpeg将图片转换为视频:

http://blog.sina.com.cn/s/blog_40d73279010113c2.html

使用Matplotlib一步步绘制函数图像

 Matplotlib, python  使用Matplotlib一步步绘制函数图像已关闭评论
11月 232018
 

文章循序渐进、清晰明了的介绍了使用matplotlib画一个函数的过程,分享下:https://www.jianshu.com/p/b1dee69767d3

matplotlib 是 python 最著名的绘图库,它提供了一整套和 matlab 相似的命令 API,十分适合交互式进行绘图。

它的文档相当完备,并且 Gallery 页面 中有上百幅缩略图,打开之后都有源程序。因此如果你需要绘制某种类型的图,只需要在这个页面中浏览/复制/粘贴一下,基本上都能搞定。

这是要实现的效果图,利用 Matplotlib 绘制函数 y = x2 的图像。

image

代码实现

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--') # 设置 x,y 轴的范围以及 label 标注 plt.xlim(-1,2)
plt.ylim(-2,3)
plt.xlabel('x')
plt.ylabel('y') # 设置坐标轴刻度线  # Tick X 范围 (-1,2) Tick Label(-1,-0.25,0.5,1.25,2) 刻度数量 5 个 new_ticks=np.linspace(-1,2,5)
plt.xticks(new_ticks) # Tick Y 范围(-2.2,-1,1,1.5,2.4) ,Tick Label (-2.2, -1, 1, 1.5, 2.4) 别名(下面的英文) plt.yticks([-2.2,-1,1,1.5,2.4],
          [r'$really\ bad$',r'$bad$',r'$normal$',r'$good$',r'$really\ good$']) # 设置坐标轴 gca() 获取坐标轴信息 ax=plt.gca() # 使用.spines设置边框:x轴;将右边颜色设置为 none。 # 使用.set_position设置边框位置:y=0的位置;(位置所有属性:outward,axes,data) ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none') # 移动坐标轴 # 将 bottom 即是 x 坐标轴设置到 y=0 的位置。 ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0)) # 将 left 即是 y 坐标轴设置到 x=0 的位置。 ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0)) # 设置标签 ax.set_title('y = x^2',fontsize=14,color='r') # 显示图像 plt.show()

首先一幅 Matplotlib 的图像组成部分介绍。

image

基本构成

在 matplotlib 中,整个图像为一个 Figure 对象。在 Figure 对象中可以包含一个或者多个 Axes 对象。每个 Axes(ax) 对象都是一个拥有自己坐标系统的绘图区域。

所属关系如下(图片来自网络):

image

图上:Title 为图像标题,Axis 为坐标轴, Label 为坐标轴标注,Tick 为刻度线,Tick Label 为刻度注释。

各个对象关系可以梳理成以下内容(图片来自网络):

image

Matplotlib 绘图步骤分析

image

注意

这里不讲解 matplotlib 的安装,我使用的是 Anaconda 的 notebook,因此,可以直接导入 matplotlib 的module,想要安装 Anaconda 的请查看的写的另一篇文章。墙裂推荐 Anaconda | 安利 Python IDE

如果说不想使用 Anaconda,可以看看这篇推荐文章,教你如何安装 matplotlib(视频和文章教程)— 莫烦 Python — Matplotlib

上面虽然贴了全部的代码,有 matplotlib 基础的人一看便懂,但是对于初学者来说,就比较抓脑了。

一、matplotlib 实现简单图像

image

使用import导入模块matplotlib.pyplot,并简写成plt使用import导入模块numpy,并简写成np。

#导入 module import matplotlib.pyplot as plt import numpy as np

使用np.linspace定义 x:范围是 (-3,3),个数是50,仿真一维数据组 (x,y) 表示曲线。

# 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 

使用plt.figure定义一个图像窗口,使用plt.plot画 (x,y) 曲线,使用plt.show显示图像。

#绘制及显示 plt.figure()
plt.plot(x, y)
plt.show()

最终代码

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 plt.figure()
plt.plot(x, y)
plt.show()

运行结果

image

看到这个,是不是和最终效果图差距很大,没关系,我们接着往下看。

二、设置 Figure 图像

使用plt.figure定义一个图像窗口:编号为 3,大小为 (8, 5)。使用plt.plot画(x,y)曲线,曲线的颜色属性(color)为红色。曲线的宽度(linewidth)为1.0。曲线的类型(linestyle)为虚线, 使用plt.show显示图像。

plt.figure(num=3,figsize=(8,5))
plt.plot(x,y,color='red',linewidth=1.0,linestyle='--')

最终代码

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--')

plt.show()

运行效果

image

三、设置坐标轴

设置 x,y 轴坐标范围及标注 label

使用plt.xlim设置x坐标轴范围:(-1, 2); 使用plt.ylim设置 y 坐标轴范围:(-2, 3);

使用plt.xlabel设置 x 坐标轴名称:’x’; 使用plt.ylabel设置 y 坐标轴名称:’I am y’;

代码实现

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--') # 设置 x,y 轴的范围以及 label 标注 plt.xlim(-1,2)
plt.ylim(-2,3)
plt.xlabel('x')
plt.ylabel('y')

plt.show()

运行结果

image

设置 x, y 刻度范围及刻度标注

设置 x 轴:使用np.linspace定义范围以及个数:范围是(-1,2); 个数是 5。

使用plt.xticks设置 x 轴刻度:范围是(-1,2); 个数是5。

设置 y 轴:使用plt.yticks设置 y 轴刻度以及名称:刻度为 [-2, -1.8, -1, 1.22, 3];对应刻度的名称为 [‘really bad’,’bad’,’normal’,’good’, ‘really good’]。

# 设置坐标轴刻度线  # Tick X 范围 (-1,2) Tick Label(-1,-0.25,0.5,1.25,2) 刻度数量 5 个 new_ticks=np.linspace(-1,2,5)
plt.xticks(new_ticks) # Tick Y 范围(-2.2,-1,1,1.5,2.4) ,Tick Label (-2.2, -1, 1, 1.5, 2.4) 别名(下面的英文) plt.yticks([-2.2,-1,1,1.5,2.4],
          [r'$really\ bad$',r'$bad$',r'$normal$',r'$good$',r'$really\ good$'])

最终代码

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--') # 设置 x,y 轴的范围以及 label 标注 plt.xlim(-1,2)
plt.ylim(-2,3)
plt.xlabel('x')
plt.ylabel('y') # 设置坐标轴刻度线  # Tick X 范围 (-1,2) Tick Label(-1,-0.25,0.5,1.25,2) 刻度数量 5 个 new_ticks=np.linspace(-1,2,5)
plt.xticks(new_ticks) # Tick Y 范围(-2.2,-1,1,1.5,2.4) ,Tick Label (-2.2, -1, 1, 1.5, 2.4) 别名(下面的英文) plt.yticks([-2.2,-1,1,1.5,2.4],
          [r'$really\ bad$',r'$bad$',r'$normal$',r'$good$',r'$really\ good$']) # 显示图像 plt.show()

运行效果,注意看 x, y 轴刻度以及标注变化

image

四、移动坐标轴

隐藏右边框和上边框:

  1. 使用plt.gca获取当前坐标轴信息。

  2. 使用.spines设置边框:右侧边框;使用.set_color设置边框颜色:默认白色;

    使用.spines设置边框:上边框;使用.set_color设置边框颜色:默认白色;

调整坐标轴至中心(将 left 边框调整到 x=0 处,将 bottom 边框调整到 y=0 处):

  1. 使用.xaxis.set_ticks_position设置 x 坐标刻度数字或名称的位置:bottom。(所有位置:top,bottom,both,default,none)。
  2. 使用.spines设置边框:x 轴;使用.set_position设置边框位置:y=0 的位置;(位置所有属性:outward,axes,data)
# 设置坐标轴 gca() 获取坐标轴信息 ax=plt.gca() # 使用.spines设置边框:x轴;将右边颜色设置为 none。 # 使用.set_position设置边框位置:y=0的位置;(位置所有属性:outward,axes,data) ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none') # 移动坐标轴 # 将 bottom 即是 x 坐标轴设置到 y=0 的位置。 ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0)) # 将 left 即是 y 坐标轴设置到 x=0 的位置。 ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

最终代码

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--') # 设置 x,y 轴的范围以及 label 标注 plt.xlim(-1,2)
plt.ylim(-2,3)
plt.xlabel('x')
plt.ylabel('y') # 设置坐标轴刻度线  # Tick X 范围 (-1,2) Tick Label(-1,-0.25,0.5,1.25,2) 刻度数量 5 个 new_ticks=np.linspace(-1,2,5)
plt.xticks(new_ticks) # Tick Y 范围(-2.2,-1,1,1.5,2.4) ,Tick Label (-2.2, -1, 1, 1.5, 2.4) 别名(下面的英文) plt.yticks([-2.2,-1,1,1.5,2.4],
          [r'$really\ bad$',r'$bad$',r'$normal$',r'$good$',r'$really\ good$']) # 设置坐标轴 gca() 获取坐标轴信息 ax=plt.gca() # 使用.spines设置边框:x轴;将右边颜色设置为 none。 # 使用.set_position设置边框位置:y=0的位置;(位置所有属性:outward,axes,data) ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none') # 移动坐标轴 # 将 bottom 即是 x 坐标轴设置到 y=0 的位置。 ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0)) # 将 left 即是 y 坐标轴设置到 x=0 的位置。 ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0)) # 显示图像 plt.show()

运行结果

image

五、设置标题

使用 .set_title 设置标题,声明标题为 y = x2,字体大小 14,颜色为 red。

# 设置标签 ax.set_title('y = x^2',fontsize=14,color='r')

最终代码

import matplotlib.pyplot as plt import numpy as np # 定义 x 变量的范围 (-3,3) 数量 50  x=np.linspace(-3,3,50)
y=x**2 # Figure 并指定大小 plt.figure(num=3,figsize=(8,5)) # 绘制 y=x^2 的图像,设置 color 为 red,线宽度是 1,线的样式是 -- plt.plot(x,y,color='red',linewidth=1.0,linestyle='--') # 设置 x,y 轴的范围以及 label 标注 plt.xlim(-1,2)
plt.ylim(-2,3)
plt.xlabel('x')
plt.ylabel('y') # 设置坐标轴刻度线  # Tick X 范围 (-1,2) Tick Label(-1,-0.25,0.5,1.25,2) 刻度数量 5 个 new_ticks=np.linspace(-1,2,5)
plt.xticks(new_ticks) # Tick Y 范围(-2.2,-1,1,1.5,2.4) ,Tick Label (-2.2, -1, 1, 1.5, 2.4) 别名(下面的英文) plt.yticks([-2.2,-1,1,1.5,2.4],
          [r'$really\ bad$',r'$bad$',r'$normal$',r'$good$',r'$really\ good$']) # 设置坐标轴 gca() 获取坐标轴信息 ax=plt.gca() # 使用.spines设置边框:x轴;将右边颜色设置为 none。 # 使用.set_position设置边框位置:y=0的位置;(位置所有属性:outward,axes,data) ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none') # 移动坐标轴 # 将 bottom 即是 x 坐标轴设置到 y=0 的位置。 ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0)) # 将 left 即是 y 坐标轴设置到 x=0 的位置。 ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0)) # 设置标签 ax.set_title('y = x^2',fontsize=14,color='r') # 显示图像 plt.show()

运行结果

image

最后,附上 matplotlib 整体结构图(图片来自网络):

MySQL的if、case语句使用总结

 mysql  MySQL的if、case语句使用总结已关闭评论
11月 212018
 

总结的不错,https://www.cnblogs.com/raobenjun/p/7998467.html

Mysql的if既可以作为表达式用,也可在存储过程中作为流程控制语句使用,如下是做为表达式使用:

IF表达式

IF(expr1,expr2,expr3)

如果 expr1 是TRUE (expr1 <> 0 and expr1 <> NULL),则 IF()的返回值为expr2; 否则返回值则为 expr3。IF() 的返回值为数字值或字符串值,具体情况视其所在语境而定。

select *,if(sva=1,"男","女") as ssva from taname where sva != ""

作为表达式的if也可以用CASE when来实现:

select CASE sva WHEN 1 THEN '男' ELSE '女' END as ssva from taname where sva != ''

在第一个方案的返回结果中, value=compare-value。而第二个方案的返回结果是第一种情况的真实结果。如果没有匹配的结果值,则返回结果为ELSE后的结果,如果没有ELSE 部分,则返回值为 NULL。

例如:

SELECT CASE 1 WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'more' END as testCol

将输出one

IFNULL(expr1,expr2)

假如expr1 不为 NULL,则 IFNULL() 的返回值为 expr1; 否则其返回值为 expr2。IFNULL()的返回值是数字或是字符串,具体情况取决于其所使用的语境。

mysql> SELECT IFNULL(1,0); -> 1 mysql> SELECT IFNULL(NULL,10); -> 10 mysql> SELECT IFNULL(1/0,10); -> 10 mysql> SELECT IFNULL(1/0,'yes'); -> 'yes'

IFNULL(expr1,expr2) 的默认结果值为两个表达式中更加“通用”的一个,顺序为STRING、 REAL或 INTEGER。

IF ELSE 做为流程控制语句使用

if实现条件判断,满足不同条件执行不同的操作,这个我们只要学编程的都知道if的作用了,下面我们来看看mysql 存储过程中的if是如何使用的吧。

IF search_condition THEN 
    statement_list [ELSEIF search_condition THEN] statement_list ... [ELSE 
    statement_list] END IF 

与PHP中的IF语句类似,当IF中条件search_condition成立时,执行THEN后的statement_list语句,否则判断ELSEIF中的条件,成立则执行其后的statement_list语句,否则继续判断其他分支。当所有分支的条件均不成立时,执行ELSE分支。search_condition是一个条件表达式,可以由“=、<、<=、>、>=、!=”等条件运算符组成,并且可以使用AND、OR、NOT对多个表达式进行组合。

例如,建立一个存储过程,该存储过程通过学生学号(student_no)和课程编号(course_no)查询其成绩(grade),返回成绩和成绩的等级,成绩大于90分的为A级,小于90分大于等于80分的为B级,小于80分大于等于70分的为C级,依次到E级。那么,创建存储过程的代码如下:

create procedure dbname.proc_getGrade (stu_no varchar(20),cour_no varchar(10)) BEGIN declare stu_grade float; select grade into stu_grade from grade where student_no=stu_no and course_no=cour_no; if stu_grade>=90 then select stu_grade,'A'; elseif stu_grade<90 and stu_grade>=80 then select stu_grade,'B'; elseif stu_grade<80 and stu_grade>=70 then select stu_grade,'C'; elseif stu_grade70 and stu_grade>=60 then select stu_grade,'D'; else select stu_grade,'E'; end if; END

注意:IF作为一条语句,在END IF后需要加上分号“;”以表示语句结束,其他语句如CASE、LOOP等也是相同的。

python之turtle库使用介绍

 python  python之turtle库使用介绍已关闭评论
11月 192018
 

turtle库真是太强大了。转自:https://blog.csdn.net/zengxiantao1994/article/details/76588580/

        Turtle库是Python语言中一个很流行的绘制图像的函数库,想象一个小乌龟,在一个横轴为x、纵轴为y的坐标系原点,(0,0)位置开始,它根据一组函数指令的控制,在这个平面坐标系中移动,从而在它爬行的路径上绘制了图形。

turtle绘图的基础知识:
1. 画布(canvas)

        画布就是turtle为我们展开用于绘图区域,我们可以设置它的大小和初始位置。

        设置画布大小

         turtle.screensize(canvwidth=None, canvheight=None, bg=None),参数分别为画布的宽(单位像素), 高, 背景颜色。

        如:turtle.screensize(800,600, “green”)

               turtle.screensize() #返回默认大小(400, 300)

        turtle.setup(width=0.5, height=0.75, startx=None, starty=None),参数:width, height: 输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例,(startx, starty): 这一坐标表示矩形窗口左上角顶点的位置, 如果为空,则窗口位于屏幕中心。

        如:turtle.setup(width=0.6,height=0.6)

               turtle.setup(width=800,height=800, startx=100, starty=100)

2. 画笔

2.1 画笔的状态

        在画布上,默认有一个坐标原点为画布中心的坐标轴,坐标原点上有一只面朝x轴正方向小乌龟。这里我们描述小乌龟时使用了两个词语:坐标原点(位置),面朝x轴正方向(方向), turtle绘图中,就是使用位置方向描述小乌龟(画笔)的状态。

2.2 画笔的属性

        画笔(画笔的属性,颜色、画线的宽度等)

        1) turtle.pensize():设置画笔的宽度;

        2) turtle.pencolor():没有参数传入,返回当前画笔颜色,传入参数设置画笔颜色,可以是字符串如”green”, “red”,也可以是RGB 3元组。

        3) turtle.speed(speed):设置画笔移动速度,画笔绘制的速度范围[0,10]整数,数字越大越快。

2.3 绘图命令

         操纵海龟绘图有着许多的命令,这些命令可以划分为3种:一种为运动命令,一种为画笔控制命令,还有一种是全局控制命令。

(1)    画笔运动命令

命令

说明

turtle.forward(distance)

向当前画笔方向移动distance像素长度

turtle.backward(distance)

向当前画笔相反方向移动distance像素长度

turtle.right(degree)

顺时针移动degree°

turtle.left(degree)

逆时针移动degree°

turtle.pendown()

移动时绘制图形,缺省时也为绘制

turtle.goto(x,y)

将画笔移动到坐标为x,y的位置

turtle.penup()

提起笔移动,不绘制图形,用于另起一个地方绘制

turtle.circle()

画圆,半径为正(负),表示圆心在画笔的左边(右边)画圆

setx( )

将当前x轴移动到指定位置

sety( )

将当前y轴移动到指定位置

setheading(angle)

设置当前朝向为angle角度

home()

设置当前画笔位置为原点,朝向东。

dot(r)

绘制一个指定直径和颜色的圆点

 

(2)     画笔控制命令

命令

说明

turtle.fillcolor(colorstring)

绘制图形的填充颜色

turtle.color(color1, color2)

同时设置pencolor=color1, fillcolor=color2

turtle.filling()

返回当前是否在填充状态

turtle.begin_fill()

准备开始填充图形

turtle.end_fill()

填充完成

turtle.hideturtle()

隐藏画笔的turtle形状

turtle.showturtle()

显示画笔的turtle形状

 

(3)    全局控制命令

命令

说明

turtle.clear()

清空turtle窗口,但是turtle的位置和状态不会改变

turtle.reset()

清空窗口,重置turtle状态为起始状态

turtle.undo()

撤销上一个turtle动作

turtle.isvisible()

返回当前turtle是否可见

stamp()

复制当前图形

turtle.write(s [,font=(“font-name”,font_size,”font_type”)])

写文本,s为文本内容,font是字体的参数,分别为字体名称,大小和类型;font为可选项,font参数也是可选项

 

(4)    其他命令

命令

说明

turtle.mainloop()或turtle.done()

启动事件循环 -调用Tkinter的mainloop函数。

必须是乌龟图形程序中的最后一个语句。

turtle.mode(mode=None)

设置乌龟模式(“standard”,“logo”或“world”)并执行重置。如果没有给出模式,则返回当前模式。

模式

初始龟标题

正角度

standard

向右(东)

逆时针

logo

向上(北)

顺时针

turtle.delay(delay=None)

设置或返回以毫秒为单位的绘图延迟。

turtle.begin_poly()

开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。

turtle.end_poly()

停止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。

turtle.get_poly()

返回最后记录的多边形。

 

3. 命令详解

        3.1 turtle.circle(radius, extent=None, steps=None)

        描述:以给定半径画圆

        参数:

        radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;

        extent(弧度) (optional);

        steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)。

举例:

circle(50) # 整圆;

circle(50,steps=3) # 三角形;

circle(120, 180) # 半圆

 

实例:

1、太阳花

# coding=utf-8
import turtle
import time

# 同时设置pencolor=color1, fillcolor=color2
turtle.color(“red”, “yellow”)

turtle.begin_fill()
for _ in range(50):
  turtle.forward(200)
  turtle.left(170)
turtle.end_fill()

turtle.mainloop()

2、五角星

# coding=utf-8
import turtle
import time

turtle.pensize(5)
turtle.pencolor(“yellow”)
turtle.fillcolor(“red”)

turtle.begin_fill()
for _ in range(5):
  turtle.forward(200)
  turtle.right(144)
turtle.end_fill()
time.sleep(2)
 
turtle.penup()
turtle.goto(-150,-120)
turtle.color(“violet”)
turtle.write(“Done”, font=(‘Arial’, 40, ‘normal’))

turtle.mainloop()

3、时钟程序

# coding=utf-8
 
import turtle
from datetime import *
 
# 抬起画笔,向前运动一段距离放下
def Skip(step):
    turtle.penup()
    turtle.forward(step)
    turtle.pendown()
 
def mkHand(name, length):
    # 注册Turtle形状,建立表针Turtle
    turtle.reset()
    Skip(-length * 0.1)
    # 开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。
    turtle.begin_poly()
    turtle.forward(length * 1.1)
    # 停止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。
    turtle.end_poly()
    # 返回最后记录的多边形。
    handForm = turtle.get_poly()
    turtle.register_shape(name, handForm)
 
def Init():
    global secHand, minHand, hurHand, printer
    # 重置Turtle指向北
    turtle.mode(“logo”)
    # 建立三个表针Turtle并初始化
    mkHand(“secHand”, 135)
    mkHand(“minHand”, 125)
    mkHand(“hurHand”, 90)
    secHand = turtle.Turtle()
    secHand.shape(“secHand”)
    minHand = turtle.Turtle()
    minHand.shape(“minHand”)
    hurHand = turtle.Turtle()
    hurHand.shape(“hurHand”)
   
    for hand in secHand, minHand, hurHand:
        hand.shapesize(1, 1, 3)
        hand.speed(0)
   
    # 建立输出文字Turtle
    printer = turtle.Turtle()
    # 隐藏画笔的turtle形状
    printer.hideturtle()
    printer.penup()
    
def SetupClock(radius):
    # 建立表的外框
    turtle.reset()
    turtle.pensize(7)
    for i in range(60):
        Skip(radius)
        if i % 5 == 0:
            turtle.forward(20)
            Skip(-radius – 20)
           
            Skip(radius + 20)
            if i == 0:
                turtle.write(int(12), align=”center”, font=(“Courier”, 14, “bold”))
            elif i == 30:
                Skip(25)
                turtle.write(int(i/5), align=”center”, font=(“Courier”, 14, “bold”))
                Skip(-25)
            elif (i == 25 or i == 35):
                Skip(20)
                turtle.write(int(i/5), align=”center”, font=(“Courier”, 14, “bold”))
                Skip(-20)
            else:
                turtle.write(int(i/5), align=”center”, font=(“Courier”, 14, “bold”))
            Skip(-radius – 20)
        else:
            turtle.dot(5)
            Skip(-radius)
        turtle.right(6)
        
def Week(t):   
    week = [“星期一”, “星期二”, “星期三”,
            “星期四”, “星期五”, “星期六”, “星期日”]
    return week[t.weekday()]
 
def Date(t):
    y = t.year
    m = t.month
    d = t.day
    return “%s %d%d” % (y, m, d)
 
def Tick():
    # 绘制表针的动态显示
    t = datetime.today()
    second = t.second + t.microsecond * 0.000001
    minute = t.minute + second / 60.0
    hour = t.hour + minute / 60.0
    secHand.setheading(6 * second)
    minHand.setheading(6 * minute)
    hurHand.setheading(30 * hour)
    
    turtle.tracer(False) 
    printer.forward(65)
    printer.write(Week(t), align=”center”,
                  font=(“Courier”, 14, “bold”))
    printer.back(130)
    printer.write(Date(t), align=”center”,
                  font=(“Courier”, 14, “bold”))
    printer.home()
    turtle.tracer(True)
 
    # 100ms后继续调用tick
    turtle.ontimer(Tick, 100)
 
def main():
    # 打开/关闭龟动画,并为更新图纸设置延迟。
    turtle.tracer(False)
    Init()
    SetupClock(160)
    turtle.tracer(True)
    Tick()
    turtle.mainloop()
 
if __name__ == “__main__”:
    main()

效果让人惊叹。

使用 Docker 搭建 Java Web 运行环境(JDK + TOMCAT) , 方式二,使用Dockerfile

 docker  使用 Docker 搭建 Java Web 运行环境(JDK + TOMCAT) , 方式二,使用Dockerfile已关闭评论
11月 142018
 

原文:https://blog.csdn.net/yjk13703623757/article/details/68944549 

Dockerfile文件内容

# 版本信息
FROM centos
MAINTAINER locutus “locutus@foxmail.com”

# OS环境配置
RUN yum install -y wget

# 安装JDK
RUN mkdir /var/tmp/jdk
RUN wget –no-check-certificate –no-cookies –header “Cookie: oraclelicense=accept-securebackup-cookie”  -P /var/tmp/jdk http://download.oracle.com/otn-pub/java/jdk/8u111-b14/jdk-8u111-linux-x64.tar.gz
RUN tar xzf /var/tmp/jdk/jdk-8u111-linux-x64.tar.gz -C /var/tmp/jdk && rm -rf /var/tmp/jdk/jdk-8u111-linux-x64.tar.gz

# 安装tomcat
RUN mkdir /var/tmp/tomcat
RUN wget -P  /var/tmp/tomcat http://archive.apache.org/dist/tomcat/tomcat-8/v8.5.8/bin/apache-tomcat-8.5.8.tar.gz
RUN tar xzf /var/tmp/tomcat/apache-tomcat-8.5.8.tar.gz -C /var/tmp/tomcat && rm -rf /var/tmp/tomcat/apache-tomcat-8.5.8.tar.gz

#设置环境变量
ENV JAVA_HOME /var/tmp/jdk/jdk1.8.0_111
ENV CATALINA_HOME /var/tmp/tomcat/apache-tomcat-8.5.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin

#打包项目并拷贝到tomcat webapps目录
RUN mkdir /var/tmp/webapp
ADD ./  /var/tmp/webapp
RUN cd  /var/tmp/webapp  && cp /var/tmp/webapp/war/sm_new.war /var/tmp/tomcat/apache-tomcat-8.5.8/webapps/

#开启内部服务端口
EXPOSE 8080

#启动tomcat服务器
CMD [“./var/tmp/tomcat/apache-tomcat-8.5.8/bin/catalina.sh”,”run”] && tail -f /var/tmp/tomcat/apache-tomcat-8.5.8/logs/catalina.out 

使用Dockerfile构建镜像

# docker build -t tomcat .    

. 表示Dockerfile在当前文件夹下,也可使用绝对路径(/path/to/Dockerfile)来表示

运行容器
# docker run -it -p 12345:8080 –name=tomcat-test  tomcat 
1
然后在命令行键入 Ctrl + p , Ctrl + q,使容器在后台运行

使用 Docker 搭建 Java Web 运行环境(JDK + TOMCAT) , 方式一

 docker  使用 Docker 搭建 Java Web 运行环境(JDK + TOMCAT) , 方式一已关闭评论
11月 142018
 

转自:https://www.cnblogs.com/zengkefu/p/5667046.html

Docker 是 2014 年最为火爆的技术之一,几乎所有的程序员都听说过它。Docker 是一种“轻量级”容器技术,它几乎动摇了传统虚拟化技术的地位,现在国内外已经有越来越多的公司开始逐步使用 Docker 来替换现有的虚拟化平台了。作为一名 Java 程序员,我们是时候一起把 Docker 学起来了!

本文会对虚拟化技术与 Docker 容器技术做一个对比,然后引出一些 Docker 的名词术语,比如:容器、镜像等,随后将使用 Docker 搭建一个 Java Web 运行环境,最后将对本文做一个总结。

我们先来回顾一下传统虚拟化技术的体系架构:

 

可见,我们在宿主机的操作系统上,可安装了多个虚拟机,而在每个虚拟机中,通过虚拟化技术,实现了一个虚拟操作系统,随后,就可以在该虚拟操作系统上,安装自己所需的应用程序了。这一切看似非常简单,但其中的技术细节是相当高深莫测的,大神级人物都不一定说得清楚。

凡是使用过虚拟机的同学,应该都知道,启动虚拟机就像启动一台计算机,初始化过程是相当慢的,我们需要等很久,才能看到登录界面。一旦虚拟机启动以后,就可以与宿主机建立网络连接,确保虚拟机与宿主机之间是互联互通的。不同的虚拟机之间却是相互隔离的,也就是说,彼此并不知道对方的存在,但每个虚拟机占用的都是宿主机的硬件与网络资源。

我们再来对比一下 Docker 技术的体系架构吧:

 

可见,在宿主机的操作系统上,有一个 Docker 服务在运行(或者称为“Docker 引擎”),在此服务上,我们可开启多个 Docker 容器,而每个 Docker 容器中可运行自己所需的应用程序,Docker 容器之间也是相互隔离的,同样地,都是占用的宿主机的硬件与网络资源。

Docker 容器相对于虚拟机而言,除了在技术实现上完全不一样以外,启动速度较虚拟机而言有本质的飞跃,启动一个容器只在眨眼瞬间。不管是虚拟机还是 Docker 容器,它们都是为了隔离应用程序的运行环境,节省我们的硬件资源,为我们开发人员提供福利。

我们再来看看 Docker 的 Logo 吧:

 

很明显,这是一只鲸鱼,它托着许多集装箱。我们可以把宿主机可当做这只鲸鱼,把相互隔离的容器可看成集装箱,每个集装箱中都包含自己的应用程序。这 Logo 简直的太形象了!

需要强调的是,笔者并非否定虚拟化技术,而是想通过本文让更多的读者了解如何使用 Docker 技术,让大家知道除了虚拟化技术以外,还有另一种替代技术,也能让应用程序隔离起来。

下面,我们将结合一个 Java Web 应用的部署过程,来描述如何“烹饪”Docker 这份美味佳肴。您准备好了吗?我们现在就开始!

原料

前提条件

首先,您要准备一个 CentOS 的操作系统,虚拟机也行。总之,可以通过 Linux 客户端工具访问到 CentOS 操作系统就行。

需要说明的是,Ubuntu 或其它 Linux 操作系统也能玩 Docker,只不过本文选择了以 CentOS 为例,仅此而已。

CentOS 具体要求如下:

  1. 必须是 64 位操作系统
  2. 建议内核在 3.8 以上

通过以下命令查看您的 CentOS 内核:

uname -r

如果执行以上命令后,输出的内核版本号低于 3.8,请参考下面的方法来来升级您的 Linux 内核。

对于 CentOS 6.5 而言,内核版本默认是 2.6。首先,可通过以下命令安装最新内核:

rpm –import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
rpm -ivh http://www.elrepo.org/elrepo-release-6-5.el6.elrepo.noarch.rpm
yum -y –enablerepo=elrepo-kernelinstall kernel-lt

随后,编辑以下配置文件:

vi /etc/grub.conf

将default=1修改为default=0。

最后,通过reboot命令重启操作系统。

重启后如果不出意外的话,再次查看内核,您的 CentOS 内核将会显示为 3.10。

如果到这里,您和我们所期望的结果是一致的。恭喜您!下面我们就一起来安装 Docker 了。

安装 Docker

只需通过以下命令即可安装 Docker 软件:

rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
yum -yinstall docker-io

可使用以下命令,查看 Docker 是否安装成功:

docker version

若输出了 Docker 的版本号,则说明安装成功了,可通过以下命令启动 Docker 服务:

service docker start

一旦 Docker 服务启动完毕,我们下面就可以开始使用 Docker 了。

做法

就像曾经安装软件一样,我们首先需要有一张刻录了该软件的光盘,如果您使用的是虚拟光驱,那么就需要运行一种名为“镜像”的文件,通过它来安装软件。在 Docker 的世界里,也有一个名为“镜像”的东西,已经安装我们所需的操作系统,我们一般成为“Docker 镜像”,本文简称“镜像”。

那么问题来了,我们从哪里下载镜像呢?

Docker 官网 确实已经提供了所有的镜像下载地址,可惜在国内却是无法访问的。幸好国内好心人提供了一个 Docker 中文网,在该网站上可以下载我们所需的 Docker 镜像。

下载镜像

我们不妨还是以 CentOS 为例,通过以下步骤,下载一个 CentOS 的镜像。

首先,访问 Docker 中文网,在首页中搜索名为“centos”的镜像,在搜索的结果中,有一个“官方镜像”,它就是我们所需的。

然后,进入 CentOS 官方镜像页面,在“Pull this repository”输入框中,有一段命令,把它复制下来,在自己的命令行上运行该命令,随后将立即下载该镜像。

最后,使用以下命令查看本地所有的镜像:

docker images

当下载完成后,您应该会看到:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
docker.cn/docker/centos   centos6             25c5298b1a36        7 weeks ago         215.8 MB

如果看到以上输出,说明您可以使用“docker.cn/docker/centos”这个镜像了,或将其称为仓库(Repository),该镜像有一个名为“centos6”的标签(Tag),此外还有一个名为“25c5298b1a36 ”的镜像 ID(可能您所看到的镜像 ID 与此处的不一致,那是正常现象,因为这个数字是随机生成的)。此外,我们可以看到该镜像只有 215.8 MB,非常小巧,而不像虚拟机的镜像文件那样庞大。

现在镜像已经有了,我们下面就需要使用该镜像,来启动容器。

启动容器

容器是在镜像的基础上来运行的,一旦容器启动了,我们就可以登录到容器中,安装自己所需的软件或应用程序。既然镜像已经下载到本地,那么如何才能启动容器呢?

只需使用以下命令即可启动容器:

docker run -i -t -v /root/software/:/mnt/software/ 25c5298b1a36/bin/bash

这条命令比较长,我们稍微分解一下,其实包含以下三个部分:

docker run <相关参数> <镜像 ID> <初始命令>

其中,相关参数包括:

  • -i:表示以“交互模式”运行容器
  • -t:表示容器启动后会进入其命令行
  • -v:表示需要将本地哪个目录挂载到容器中,格式:-v <宿主机目录>:<容器目录>

假设我们的所有安装程序都放在了宿主机的/root/software/目录下,现在需要将其挂载到容器的/mnt/software/目录下。

需要说明的是,不一定要使用“镜像 ID”,也可以使用“仓库名:标签名”,例如:docker.cn/docker/centos:centos6。

初始命令表示一旦容器启动,需要运行的命令,此时使用“/bin/bash”,表示什么也不做,只需进入命令行即可。

安装相关软件

为了搭建 Java Web 运行环境,我们需要安装 JDK 与 Tomcat,下面的过程均在容器内部进行。我们不妨选择/opt/目录作为安装目录,首先需要通过cd /opt/命令进入该目录。

安装 JDK

首先,解压 JDK 程序包:

tar -zxf/mnt/software/jdk-7u67-linux-x64.tar.gz -C .

然后,重命名 JDK 目录:

mv jdk1.7.0_67/ jdk/

安装 Tomcat

首先,解压 Tomcat 程序包:

tar -zxf/mnt/software/apache-tomcat-7.0.55.tar.gz -C .

然后,重命名 Tomcat 目录:

mv apache-tomcat-7.0.55/ tomcat/

设置环境变量

首先,编辑.bashrc文件

vi ~/.bashrc

然后,在该文件末尾添加如下配置:

export JAVA_HOME=/opt/jdk
export PATH=$PATH:$JAVA_HOME

最后,需要使用source命令,让环境变量生效:

source ~/.bashrc

编写运行脚本

我们需要编写一个运行脚本,当启动容器时,运行该脚本,启动 Tomcat,具体过程如下:

首先,创建运行脚本:

vi /root/run.sh

然后,编辑脚本内容如下:

#!/bin/bash
source ~/.bashrc
sh/opt/tomcat/bin/catalina.sh run

注意:这里必须先加载环境变量,然后使用 Tomcat 的运行脚本来启动 Tomcat 服务。

最后,为运行脚本添加执行权限:

chmod u+x/root/run.sh

退出容器

当以上步骤全部完成后,可使用exit命令,退出容器。

随后,可使用如下命令查看正在运行的容器:

dockerps

此时,您应该看不到任何正在运行的程序,因为刚才已经使用exit命令退出的容器,此时容器处于停止状态,可使用如下命令查看所有容器:

dockerps -a

输出如下内容:

CONTAINER ID        IMAGE                             COMMAND             CREATED             STATUS                      PORTS               NAMES
57c312bbaad1        docker.cn/docker/centos:centos6  “/bin/bash”         27 minutes ago      Exited (0) 19 seconds ago                       naughty_goldstine

记住以上CONTAINER ID(容器 ID),随后我们将通过该容器,创建一个可运行 Java Web 的镜像。

创建 Java Web 镜像

使用以下命令,根据某个“容器 ID”来创建一个新的“镜像”:

docker commit 57c312bbaad1 huangyong/javaweb:0.1

该容器的 ID 是“57c312bbaad1”,所创建的镜像名是“huangyong/javaweb:0.1”,随后可使用镜像来启动 Java Web 容器。

启动 Java Web 容器

有必要首先使用docker images命令,查看当前所有的镜像:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
huangyong/javaweb         0.1                 fc826a4706af        38 seconds ago      562.8 MB
docker.cn/docker/centos   centos6             25c5298b1a36        7 weeks ago         215.8 MB

可见,此时已经看到了最新创建的镜像“huangyong/javaweb:0.1”,其镜像 ID 是“fc826a4706af”。正如上面所描述的那样,我们可以通过“镜像名”或“镜像 ID”来启动容器,与上次启动容器不同的是,我们现在不再进入容器的命令行,而是直接启动容器内部的 Tomcat 服务。此时,需要使用以下命令:

docker run -d -p 58080:8080 –name javaweb huangyong/javaweb:0.1/root/run.sh

稍作解释:

  • -d:表示以“守护模式”执行/root/run.sh脚本,此时 Tomcat 控制台不会出现在输出终端上。
  • -p:表示宿主机与容器的端口映射,此时将容器内部的 8080 端口映射为宿主机的 58080 端口,这样就向外界暴露了 58080 端口,可通过 Docker 网桥来访问容器内部的 8080 端口了。
  • –name:表示容器名称,用一个有意义的名称命名即可。

关于 Docker 网桥的内容,需要补充说明一下。实际上 Docker 在宿主机与容器之间,搭建了一座网络通信的桥梁,我们可通过宿主机 IP 地址与端口号来映射容器内部的 IP 地址与端口号,

在一系列参数后面的是“镜像名”或“镜像 ID”,怎么方便就怎么来。最后是“初始命令”,它是上面编写的运行脚本,里面封装了加载环境变量并启动 Tomcat 服务的命令。

当运行以上命令后,会立即输出一长串“容器 ID”,我们可通过docker ps命令来查看当前正在运行的容器。

CONTAINER ID        IMAGE                   COMMAND             CREATED             STATUS              PORTS                     NAMES
82f47923f926        huangyong/javaweb:0.1  “/root/run.sh”      4 seconds ago       Up 3 seconds        0.0.0.0:58080->8080/tcp   javaweb

品尝

在浏览器中,输入以下地址,即可访问 Tomcat 首页:

http://192.168.65.132:58080/

注意:这里使用的是宿主机的 IP 地址,与对外暴露的端口号 58080,它映射容器内部的端口号 8080。

总结

通过本文,我们了解了 Docker 是什么?它与虚拟机的差别在哪里?以及如何安装 Docker?如何下载 Docker 镜像?如何运行 Docker 容器?如何在容器内安装应用程序?如何在容器上创建镜像?如何以服务的方式启动容器?这一切看似简单,但操作也是相当繁琐的,不过熟能生巧,需要我们不断地操练。

除了这种手工生成 Docker 镜像的方式以外,还有一种更像是写代码一样,可以自动地创建 Docker 镜像的方式。只需要我们编写一个 Dockerfile 文件,随后使用docker build命令即可完成以上所有的手工操作。

入门OkHttp使用

 okhttp  入门OkHttp使用已关闭评论
10月 222018
 

OkHttp入门资料,推荐!来自:https://blog.csdn.net/mynameishuangshuai/article/details/51303446

       OkHttp官网地址:http://square.github.io/okhttp/ 
       OkHttp GitHub地址:https://github.com/square/okhttp 
官网的自我介绍: 
       HTTP is the way modern applications network. It’s how we exchange data & media. Doing HTTP efficiently makes your stuff load faster and saves bandwidth. 
OkHttp is an HTTP client that’s efficient by default:

•   HTTP/2 support allows all requests to the same host to share a socket.
•   Connection pooling reduces request latency (if HTTP/2 isn’t available).
•   Transparent GZIP shrinks download sizes.
•   Response caching avoids the network completely for repeat requests.

       OkHttp perseveres when the network is troublesome: it will silently recover from common connection problems. If your service has multiple IP addresses OkHttp will attempt alternate addresses if the first connect fails. This is necessary for IPv4+IPv6 and for services hosted in redundant data centers. OkHttp initiates new connections with modern TLS features (SNI, ALPN), and falls back to TLS 1.0 if the handshake fails. 
       Using OkHttp is easy. Its request/response API is designed with fluent builders and immutability. It supports both synchronous blocking calls and async calls with callbacks. 
       OkHttp supports Android 2.3 and above. For Java, the minimum requirement is 1.7. 
       概括起来说OkHttp是一款优秀的HTTP框架,它支持get请求和post请求,支持基于Http的文件上传和下载,支持加载图片,支持下载文件透明的GZIP压缩,支持响应缓存避免重复的网络请求,支持使用连接池来降低响应延迟问题。

配置方法
(一)导入Jar包 
点击下面链接下载最新v3.2.0 JAR 
http://repo1.maven.org/maven2/com/squareup/okhttp3/okhttp/3.2.0/okhttp-3.2.0.jar 
(二)通过构建方式导入 
MAVEN

<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>3.2.0</version>
</dependency>

GRADLE

compile ‘com.squareup.okhttp3:okhttp:3.2.0’
基本要求
Requests(请求)
       每一个HTTP请求中都应该包含一个URL,一个GET或POST方法以及Header或其他参数,当然还可以含特定内容类型的数据流。

Responses(响应)
       响应则包含一个回复代码(200代表成功,404代表未找到),Header和定制可选的body。

基本使用
       在日常开发中最常用到的网络请求就是GET和POST两种请求方式。

HTTP GET
OkHttpClient client = new OkHttpClient();
String run(String url) throws IOException {
    Request request = new Request.Builder().url(url).build();
    Response response = client.newCall(request).execute();
    if (response.isSuccessful()) {
        return response.body().string();
    } else {
        throw new IOException(“Unexpected code ” + response);
    }
}
Request是OkHttp中访问的请求,Builder是辅助类,Response即OkHttp中的响应。 
Response类:

public boolean isSuccessful()
Returns true if the code is in [200..300), which means the request was successfully received, understood, and accepted.
response.body()返回ResponseBody类
可以方便的获取string

public final String string() throws IOException
Returns the response as a string decoded with the charset of the Content-Type header. If that header is either absent or lacks a charset, this will attempt to decode the response body as UTF-8.
Throws:
IOException
当然也能获取到流的形式: 
public final InputStream byteStream()

HTTP POST
POST提交Json数据

public static final MediaType JSON = MediaType.parse(“application/json; charset=utf-8”);
OkHttpClient client = new OkHttpClient();
String post(String url, String json) throws IOException {
    RequestBody body = RequestBody.create(JSON, json);
    Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
    Response response = client.newCall(request).execute();
    f (response.isSuccessful()) {
        return response.body().string();
    } else {
        throw new IOException(“Unexpected code ” + response);
    }
}
使用Request的post方法来提交请求体RequestBody 
POST提交键值对 
OkHttp也可以通过POST方式把键值对数据传送到服务器

OkHttpClient client = new OkHttpClient();
String post(String url, String json) throws IOException {
    RequestBody formBody = new FormEncodingBuilder()
    .add(“platform”, “android”)
    .add(“name”, “bug”)
    .add(“subject”, “XXXXXXXXXXXXXXX”)
    .build();

    Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();

    Response response = client.newCall(request).execute();
    if (response.isSuccessful()) {
        return response.body().string();
    } else {
        throw new IOException(“Unexpected code ” + response);
    }
}
案例
布局文件:

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
              android:layout_width=”match_parent”
              android:layout_height=”match_parent”
              android:orientation=”vertical”>

    <LinearLayout
        android:layout_width=”match_parent”
        android:layout_height=”wrap_content”
        android:gravity=”center_horizontal”
        android:orientation=”horizontal”>

        <Button
            android:id=”@+id/bt_get”
            android:layout_width=”wrap_content”
            android:layout_height=”wrap_content”
            android:text=”乌云Get请求”/>

        <Button
            android:id=”@+id/bt_post”
            android:layout_width=”wrap_content”
            android:layout_height=”wrap_content”
            android:text=”乌云Post请求”/>

    </LinearLayout>

    <TextView
        android:id=”@+id/tv_show”
        android:layout_width=”match_parent”
        android:layout_height=”wrap_content”/>
</LinearLayout>
 
Java代码: 
由于android本身是不允许在UI线程做网络请求操作的,所以我们自己写个线程完成网络操作

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.squareup.okhttp.FormEncodingBuilder;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.Request;
import com.squareup.okhttp.RequestBody;
import com.squareup.okhttp.Response;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button bt_get;
    private Button bt_post;

    final OkHttpClient client = new OkHttpClient();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);

        bt_get=(Button)findViewById(R.id.bt_get);
        bt_post=(Button)findViewById(R.id.bt_post);

        bt_get.setOnClickListener(this);
        bt_post.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.bt_get:
                getRequest();
                break;

            case R.id.bt_post:
                postRequest();
                break;

        }
    }

    private void getRequest() {

        final Request request=new Request.Builder()
                .get()
                .tag(this)
                .url(“http://www.wooyun.org”)
                .build();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Response response = null;
                try {
                    response = client.newCall(request).execute();
                    if (response.isSuccessful()) {
                        Log.i(“WY”,”打印GET响应的数据:” + response.body().string());
                    } else {
                        throw new IOException(“Unexpected code ” + response);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    private void postRequest() {

        RequestBody formBody = new FormEncodingBuilder()
                .add(“”,””)
                .build();

        final Request request = new Request.Builder()
                .url(“http://www.wooyun.org”)
                .post(formBody)
                .build();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Response response = null;
                try {
                    response = client.newCall(request).execute();
                    if (response.isSuccessful()) {
                        Log.i(“WY”,”打印POST响应的数据:” + response.body().string());
                    } else {
                        throw new IOException(“Unexpected code ” + response);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

}
执行结果: 

官方Recipes
Synchronous Get(同步Get)
下载一个文件,打印他的响应头,以string形式打印响应体。 
       响应体的 string() 方法对于小文档来说十分方便、高效。但是如果响应体太大(超过1MB),应避免适应 string()方法 ,因为他会将把整个文档加载到内存中。对于超过1MB的响应body,应使用流的方式来处理body。

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://publicobject.com/helloworld.txt”)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    Headers responseHeaders = response.headers();
    for (int i = 0; i < responseHeaders.size(); i++) {
      System.out.println(responseHeaders.name(i) + “: ” + responseHeaders.value(i));
    }

    System.out.println(response.body().string());
  }
Asynchronous Get(异步Get)
       在一个工作线程中下载文件,当响应可读时回调Callback接口。读取响应时会阻塞当前线程。OkHttp现阶段不提供异步api来接收响应体。

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://publicobject.com/helloworld.txt”)
        .build();

    client.newCall(request).enqueue(new Callback() {
      @Override public void onFailure(Call call, IOException e) {
        e.printStackTrace();
      }

      @Override public void onResponse(Call call, Response response) throws IOException {
        if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

        Headers responseHeaders = response.headers();
        for (int i = 0, size = responseHeaders.size(); i < size; i++) {
          System.out.println(responseHeaders.name(i) + “: ” + responseHeaders.value(i));
        }

        System.out.println(response.body().string());
      }
    });
  }
Accessing Headers(提取响应头)
典型的HTTP头 像是一个 Map

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“https://api.github.com/repos/square/okhttp/issues”)
        .header(“User-Agent”, “OkHttp Headers.java”)
        .addHeader(“Accept”, “application/json; q=0.5”)
        .addHeader(“Accept”, “application/vnd.github.v3+json”)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(“Server: ” + response.header(“Server”));
    System.out.println(“Date: ” + response.header(“Date”));
    System.out.println(“Vary: ” + response.headers(“Vary”));
  }
Posting a String(Post方式提交String)
       使用HTTP POST提交请求到服务。这个例子提交了一个markdown文档到web服务,以HTML方式渲染markdown。因为整个请求体都在内存中,因此避免使用此api提交大文档(大于1MB)。

public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse(“text/x-markdown; charset=utf-8”);

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    String postBody = “”
        + “Releases\n”
        + “——–\n”
        + “\n”
        + ” * _1.0_ May 6, 2013\n”
        + ” * _1.1_ June 15, 2013\n”
        + ” * _1.2_ August 11, 2013\n”;

    Request request = new Request.Builder()
        .url(“https://api.github.com/markdown/raw”)
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }

Post Streaming(Post方式提交流)

       以流的方式POST提交请求体。请求体的内容由流写入产生。这个例子是流直接写入Okio的BufferedSink。你的程序可能会使用OutputStream,你可以使用BufferedSink.outputStream()来获取。.

public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse(“text/x-markdown; charset=utf-8”);

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    RequestBody requestBody = new RequestBody() {
      @Override public MediaType contentType() {
        return MEDIA_TYPE_MARKDOWN;
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        sink.writeUtf8(“Numbers\n”);
        sink.writeUtf8(“——-\n”);
        for (int i = 2; i <= 997; i++) {
          sink.writeUtf8(String.format(” * %s = %s\n”, i, factor(i)));
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + ” × ” + i;
        }
        return Integer.toString(n);
      }
    };

    Request request = new Request.Builder()
        .url(“https://api.github.com/markdown/raw”)
        .post(requestBody)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }
Posting a File(Post方式提交文件)
以文件作为请求体是十分简单的。

public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse(“text/x-markdown; charset=utf-8”);

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    File file = new File(“README.md”);

    Request request = new Request.Builder()
        .url(“https://api.github.com/markdown/raw”)
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }
Posting form parameters(Post方式提交表单)
       使用FormEncodingBuilder来构建和HTML标签相同效果的请求体。键值对将使用一种HTML兼容形式的URL编码来进行编码。

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    RequestBody formBody = new FormBody.Builder()
        .add(“search”, “Jurassic Park”)
        .build();
    Request request = new Request.Builder()
        .url(“https://en.wikipedia.org/w/index.php”)
        .post(formBody)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }
Posting a multipart request(Post方式提交分块请求)
       MultipartBuilder可以构建复杂的请求体,与HTML文件上传形式兼容。多块请求体中每块请求都是一个请求体,可以定义自己的请求头。这些请求头可以用来描述这块请求,例如他的Content-Disposition。如果Content-Length和Content-Type可用的话,他们会被自动添加到请求头中。

private static final String IMGUR_CLIENT_ID = “…”;
  private static final MediaType MEDIA_TYPE_PNG = MediaType.parse(“image/png”);

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
    RequestBody requestBody = new MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart(“title”, “Square Logo”)
        .addFormDataPart(“image”, “logo-square.png”,
            RequestBody.create(MEDIA_TYPE_PNG, new File(“website/static/logo-square.png”)))
        .build();

    Request request = new Request.Builder()
        .header(“Authorization”, “Client-ID ” + IMGUR_CLIENT_ID)
        .url(“https://api.imgur.com/3/image”)
        .post(requestBody)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }
Parse a JSON Response With Gson(使用GSON解析JSON响应)
       Gson是一个在JSON和Java对象之间转换非常方便的api。这里我们用Gson来解析Github API的JSON响应。 
注意:ResponseBody.charStream()使用响应头Content-Type指定的字符集来解析响应体。默认是UTF-8。

private final OkHttpClient client = new OkHttpClient();
  private final Gson gson = new Gson();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“https://api.github.com/gists/c2a7c39532239ff261be”)
        .build();
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    Gist gist = gson.fromJson(response.body().charStream(), Gist.class);
    for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
      System.out.println(entry.getKey());
      System.out.println(entry.getValue().content);
    }
  }

  static class Gist {
    Map<String, GistFile> files;
  }

  static class GistFile {
    String content;
  }
Response Caching(响应缓存)
       为了缓存响应,你需要一个你可以读写的缓存目录,和缓存大小的限制。这个缓存目录应该是私有的,不信任的程序应不能读取缓存内容。 
       一个缓存目录同时拥有多个缓存访问是错误的。大多数程序只需要调用一次new OkHttp(),在第一次调用时配置好缓存,然后其他地方只需要调用这个实例就可以了。否则两个缓存示例互相干扰,破坏响应缓存,而且有可能会导致程序崩溃。 
       响应缓存使用HTTP头作为配置。你可以在请求头中添加Cache-Control: max-stale=3600 ,OkHttp缓存会支持。你的服务通过响应头确定响应缓存多长时间,例如使用Cache-Control: max-age=9600。

private final OkHttpClient client;

  public CacheResponse(File cacheDirectory) throws Exception {
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://publicobject.com/helloworld.txt”)
        .build();

    Response response1 = client.newCall(request).execute();
    if (!response1.isSuccessful()) throw new IOException(“Unexpected code ” + response1);

    String response1Body = response1.body().string();
    System.out.println(“Response 1 response:          ” + response1);
    System.out.println(“Response 1 cache response:    ” + response1.cacheResponse());
    System.out.println(“Response 1 network response:  ” + response1.networkResponse());

    Response response2 = client.newCall(request).execute();
    if (!response2.isSuccessful()) throw new IOException(“Unexpected code ” + response2);

    String response2Body = response2.body().string();
    System.out.println(“Response 2 response:          ” + response2);
    System.out.println(“Response 2 cache response:    ” + response2.cacheResponse());
    System.out.println(“Response 2 network response:  ” + response2.networkResponse());

    System.out.println(“Response 2 equals Response 1? ” + response1Body.equals(response2Body));
  }
       为了防止使用缓存的响应,可以用CacheControl.FORCE_NETWORK。为了防止它使用网络,使用CacheControl.FORCE_CACHE。需要注意的是:如果您使用FORCE_CACHE和网络的响应需求,OkHttp则会返回一个504提示,告诉你不可满足请求响应。 
       Canceling a Call(取消一个Call) 
       使用Call.cancel()可以立即停止掉一个正在执行的call。如果一个线程正在写请求或者读响应,将会引发IOException。当call没有必要的时候,使用这个api可以节约网络资源。例如当用户离开一个应用时。不管同步还是异步的call都可以取消。 
       你可以通过tags来同时取消多个请求。当你构建一请求时,使用RequestBuilder.tag(tag)来分配一个标签。之后你就可以用OkHttpClient.cancel(tag)来取消所有带有这个tag的call。.

 private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://httpbin.org/delay/2”) // This URL is served with a 2 second delay.
        .build();

    final long startNanos = System.nanoTime();
    final Call call = client.newCall(request);

    // Schedule a job to cancel the call in 1 second.
    executor.schedule(new Runnable() {
      @Override public void run() {
        System.out.printf(“%.2f Canceling call.%n”, (System.nanoTime() – startNanos) / 1e9f);
        call.cancel();
        System.out.printf(“%.2f Canceled call.%n”, (System.nanoTime() – startNanos) / 1e9f);
      }
    }, 1, TimeUnit.SECONDS);

    try {
      System.out.printf(“%.2f Executing call.%n”, (System.nanoTime() – startNanos) / 1e9f);
      Response response = call.execute();
      System.out.printf(“%.2f Call was expected to fail, but completed: %s%n”,
          (System.nanoTime() – startNanos) / 1e9f, response);
    } catch (IOException e) {
      System.out.printf(“%.2f Call failed as expected: %s%n”,
          (System.nanoTime() – startNanos) / 1e9f, e);
    }
  }
Timeouts(超时)
       没有响应时使用超时结束call。没有响应的原因可能是客户点链接问题、服务器可用性问题或者这之间的其他东西。OkHttp支持连接,读取和写入超时。

private final OkHttpClient client;

  public ConfigureTimeouts() throws Exception {
    client = new OkHttpClient.Builder()
        .connectTimeout(10, TimeUnit.SECONDS)
        .writeTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://httpbin.org/delay/2”) // This URL is served with a 2 second delay.
        .build();

    Response response = client.newCall(request).execute();
    System.out.println(“Response completed: ” + response);
  }
Per-call Configuration(每个Call的配置)
       使用OkHttpClient,所有的HTTP Client配置包括代理设置、超时设置、缓存设置。当你需要为单个call改变配置的时候,clone 一个 OkHttpClient。这个api将会返回一个浅拷贝(shallow copy),你可以用来单独自定义。下面的例子中,我们让一个请求是500ms的超时、另一个是3000ms的超时。

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://httpbin.org/delay/1”) // This URL is served with a 1 second delay.
        .build();

    try {
      // Copy to customize OkHttp for this request.
      OkHttpClient copy = client.newBuilder()
          .readTimeout(500, TimeUnit.MILLISECONDS)
          .build();

      Response response = copy.newCall(request).execute();
      System.out.println(“Response 1 succeeded: ” + response);
    } catch (IOException e) {
      System.out.println(“Response 1 failed: ” + e);
    }

    try {
      // Copy to customize OkHttp for this request.
      OkHttpClient copy = client.newBuilder()
          .readTimeout(3000, TimeUnit.MILLISECONDS)
          .build();

      Response response = copy.newCall(request).execute();
      System.out.println(“Response 2 succeeded: ” + response);
    } catch (IOException e) {
      System.out.println(“Response 2 failed: ” + e);
    }
  }
Handling authentication(处理验证)
       OkHttp会自动重试未验证的请求。当响应是401 Not Authorized时,Authenticator会被要求提供证书。Authenticator的实现中需要建立一个新的包含证书的请求。如果没有证书可用,返回null来跳过尝试。

 private final OkHttpClient client;

  public Authenticate() {
    client = new OkHttpClient.Builder()
        .authenticator(new Authenticator() {
          @Override public Request authenticate(Route route, Response response) throws IOException {
            System.out.println(“Authenticating for response: ” + response);
            System.out.println(“Challenges: ” + response.challenges());
            String credential = Credentials.basic(“jesse”, “password1”);
            return response.request().newBuilder()
                .header(“Authorization”, credential)
                .build();
          }
        })
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url(“http://publicobject.com/secrets/hellosecret.txt”)
        .build();

    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException(“Unexpected code ” + response);

    System.out.println(response.body().string());
  }
To avoid making many retries when authentication isn’t working, you can return null to give up. For example, you may want to skip the retry when these exact credentials have already been attempted:

if (credential.equals(response.request().header(“Authorization”))) {
    return null; // If we already failed with these credentials, don’t retry.
   }
You may also skip the retry when you’ve hit an application-defined attempt limit:
  if (responseCount(response) >= 3) {
    return null; // If we’ve failed 3 times, give up.
  }
This above code relies on this responseCount() method:
  private int responseCount(Response response) {
    int result = 1;
    while ((response = response.priorResponse()) != null) {
      result++;
    }
    return result;
  }
OkHttp官方文档:https://github.com/square/okhttp/wiki 
参考链接:http://www.cnblogs.com/ct2011/p/3997368.html

apache 的commons下有个DBUtils, 封装了jdbc的实现(c3p0和QueryRunner的结合使用)

 dbutils  apache 的commons下有个DBUtils, 封装了jdbc的实现(c3p0和QueryRunner的结合使用)已关闭评论
6月 012018
 

最近刚发现apache 的commons下有个DBUtils, 封装了jdbc的实现,用起来真方便,分享一篇文章:https://www.cnblogs.com/biehongli/p/6536072.html

1DBUtils中的QueryRunner的使用:

1.1QueryRunner中提供了对SQL语句操作的api

1.2:主要有三个方法:

1.2.1query():用于执行select(查询);

1.2.2update():用于执行insert(插入)/update(更新)/delete(删除);

1.2.3batch():批处理;

2c3p0QueryRunner的结合使用:

2.1:首先导包,如下所示的包;

c3p0-0.9.1.2.jar
commons-dbutils-1.6.jar
mysql-connector-java-5.1.12-bin.jar

  2.2:当然导包之前你需要创建好数据库和数据表哦!~~~

  
src目录下面记住配置c3p0-config.xml文件

<c3p0-config>
    
    <!– c3p0默认配置,下面还可以配置多个数据库 –>
    <default-config>
        <property name=”jdbcUrl”>jdbc:mysql://localhost:3306/test
        </property>
        <property name=”driverClass”>com.mysql.jdbc.Driver</property>
        <property name=”user”>root</property>
        <property name=”password”>123456</property>
        <property name=”initialPoolSize”>6</property>
        <property name=”maxPoolSize”>50</property>
        <property name=”maxIdleTime”>1000</property>
    </default-config>

</c3p0-config>

2.3:创建实体类,如User.java,源码如下,

package com.bie.po;
/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午12:55:21 

*/
public class User {

    private int id;
    private String name;
    private String password;
    private String email;
    private String phone;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    @Override
    public String toString() {
        return “User [id=” + id + “, name=” + name + “, password=” + password + “, email=” + email + “, phone=” + phone
                + “]”;
    }
    
    
}

2.4:创建好实体类之后就可以根据MVC模式分层进行开发,这里只是模拟,所以创建dao层和servic层和test层。test层进行测试;

所以先创建dao层进行创建接口,再创建实现接口的类,当然实现c3p0QueryRunner的关键代码就是dao层哦,切记;

当然了还有工具类utils层提取的公共的方法;

package com.bie.dao;

import java.util.List;

import com.bie.po.User;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午5:46:38 

*/
public interface UserDao {

    /***
     * 查询所有的用户信息
     * @return
     */
    public List<User> selectUser();
    
    /***
     * 根据编号查询
     * @param id
     * @return
     */
    public User selectUserId(int id);
    
    
    /***
     * 根据条件查询信息
     * @param user
     * @return
     */
    public List<User> select(String sql,List<Object> list);
    
    
}

package com.bie.dao.impl;

import java.util.List;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import com.bie.dao.UserDao;
import com.bie.po.User;
import com.bie.util.BaseUtils;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午5:47:35 

*/
public class UserDaoImpl implements UserDao{

    @Override
    public List<User> selectUser() {
        //创建QueryRunner
        //记住查询是BeanListHandler区别增删改的方法BeanHandler
        QueryRunner qr=BaseUtils.getQueryRunner();
        try {
            String sql=”select * from user “;
            //这句话就相当于之前写的下面这一长串代码,这就是QueryRunner的方便之处
            /***
             *User user=new User();
               user.setId(rs.getInt(“id”));
               user.setName(rs.getString(“name”));
               user.setPassword(rs.getString(“password”));
               user.setEmail(rs.getString(“email”));
               user.setPhone(rs.getString(“phone”));
             */
            return qr.query(sql, new BeanListHandler<User>(User.class));
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public User selectUserId(int id) {
        //创建QueryRunner
        QueryRunner qr=BaseUtils.getQueryRunner();
        String sql=”select * from user where id=? “;
        try {
            //使用QueryRunner的强大之处在于此处。
            return qr.query(sql,new BeanHandler<User>(User.class), id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public List<User> select(String sql,List<Object> list) {
        //创建QueryRunner
        QueryRunner qr=BaseUtils.getQueryRunner();
        try {
            //第一个参数是传来的sql,第二个是实现实体类的设置,第三个是集合转化为数组
            return qr.query(sql, new BeanListHandler<User>(User.class), list.toArray());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    
}

这里将BaseUtils类写到这里,因为这个也是c3p0QueryRunner的核心

package com.bie.util;

import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.apache.commons.dbutils.QueryRunner;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午1:29:50 
* 数据库连接工具类
*/
public class BaseUtils {

    //初始化c3p0
    private static DataSource dataSource=null;
    
    static{
        //自动加载src目录下面的c3p0的配置文件,【c3p0-config.xml】
        dataSource = new ComboPooledDataSource();
    }
    
    public static QueryRunner getQueryRunner(){
        //第一步:创建QueryRunner对象,传入连接池对象
        //在创建QueryRunner对象的时候,如果传入数据对象dataSource,
        //那么在使用QueryRunner对象的方法时候,就不需要传入连接对象
        QueryRunner query=new QueryRunner(dataSource);
        //第二步:会自动从数据源中获取连接(不用关闭连接)
        return query;
    }
    
    /***
     * 实现增删改的公共方法
     * @param sql
     * @param arr
     * @return
     */
    public static boolean addUpdateDelete(String sql,Object[] arr){
        QueryRunner qr=getQueryRunner();
        int count;
        try {
            count = qr.update(sql, arr);
            if(count>0){
                return true;
            }else{
                return false;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }
    
}

2.5:完成dao层和BaseUtils层之后可以直接在service层进行增删改,

package com.bie.service;

import java.util.List;

import com.bie.po.User;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午7:10:32 

*/
public interface UserService {

    /***
     * 根据条件查询用户信息
     * @param user
     * @return
     */
    public List<User> select(User user);
    
    /***
     * 添加用户信息
     * @param user
     * @return
     */
    public boolean insertUser(User user);
    
    /***
     * 修改用户的信息
     * @param user
     * @return
     */
    public boolean updateUser(User user);
    
    /***
     * 删除用户信息
     * @param id
     * @return
     */
    public boolean deleteUser(int id);
}

package com.bie.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.bie.dao.UserDao;
import com.bie.dao.impl.UserDaoImpl;
import com.bie.po.User;
import com.bie.service.UserService;
import com.bie.util.BaseUtils;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午7:10:48 

*/
public class UserServiceImpl implements UserService{
    
    private UserDao dao=new UserDaoImpl();
    
    @Override
    public List<User> select(User user) {
        StringBuilder sql=new StringBuilder(“select * from user where 1=1 “);
        List<Object> list=new ArrayList<Object>();
        if(user!=null){
            //根据编号查询
            if(user.getId()!=0 && !””.equals(user.getId())){
                sql.append(” and id = ? “);
                list.add(user.getId());
            }
            
            //根据名称模糊查询,模糊查询”” %% “” ++
            if(user.getName()!=null && !””.equals(user.getName())){
                sql.append(” and name like ? “);
                list.add(“%”+user.getName()+”%”);
            }
        }
        
        return dao.select(sql.toString(), list);
    }

    @Override
    public boolean insertUser(User user) {
        String sql=”insert into user values(0,?,?,?,?)”;
        List<Object> list=new ArrayList<>();
        if(user!=null){
            list.add(user.getName());
            list.add(user.getPassword());
            list.add(user.getEmail());
            list.add(user.getPhone());
        }
        try {
            return BaseUtils.addUpdateDelete(sql, list.toArray());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean updateUser(User user) {
        String sql=”update user set name=?,password=?,email=?,phone=? where id=? “;
        List<Object> list=new ArrayList<>();
        if(user!=null){
            list.add(user.getName());
            list.add(user.getPassword());
            list.add(user.getEmail());
            list.add(user.getPhone());
            
            //根据编号修改信息
            list.add(user.getId());
        }
        
        try {
            return BaseUtils.addUpdateDelete(sql, list.toArray());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean deleteUser(int id) {
        String sql=”delete from user where id=? “;
        List<Object> list=new ArrayList<>();
        if(id!=0){
            //根据编号修改信息
            list.add(id);
        }
        
        try {
            return BaseUtils.addUpdateDelete(sql, list.toArray());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    
}

2.6:使用junit测试,完成使用c3p0QueryRunner的练习;

package com.bie.test;

import java.util.List;

import org.junit.Test;

import com.bie.dao.UserDao;
import com.bie.dao.impl.UserDaoImpl;
import com.bie.po.User;
import com.bie.service.UserService;
import com.bie.service.impl.UserServiceImpl;

/** 
* @author BieHongLi 
* @version 创建时间:2017年3月11日 下午5:57:25 

*/
public class QueryRunnerTest {

    private UserDao dao=new UserDaoImpl();
    private UserService service=new UserServiceImpl();
    
    //查询所有信息的测试
    @Test
    public void selectUser(){
        List<User> list=dao.selectUser();
        for(User u:list){
            System.out.println(u);
        }
    }
    
    //根绝id查询的信息
    @Test
    public void selectUserId(){
        User user=dao.selectUserId(1);
        System.out.println(user);
    }
    
    //根据条件查询信息
    @Test
    public void select(){
        User user=new User();
        user.setName(“张三”);
        List<User> list=service.select(user);
        for(User u:list){
            System.out.println(u);
        }
    }
    
    @Test
    public void insertUser(){
        User user=new User();
        user.setName(“张三”);
        user.setPassword(“123456”);
        user.setEmail(“1748@qq.com”);
        user.setPhone(“11223”);
        
        boolean mark=service.insertUser(user);
        if(mark){
            System.out.println(“插入成功”);
        }else{
            System.out.println(“插入失败”);
        }
    }
    
    
    @Test
    public void update(){
        User user=new User();
        user.setName(“李四”);
        user.setId(1);
        
        boolean mark=service.updateUser(user);
        if(mark){
            System.out.println(“修改成功”);
        }else{
            System.out.println(“修改失败”);
        }
    }
    
    @Test
    public void delete(){
        boolean mark=service.deleteUser(1);
        if(mark){
            System.out.println(“用户信息删除成功”);
        }else{
            System.out.println(“用户信息删除失败”);
        }
    }
    
}

关于nagios配置简介

 nagios  关于nagios配置简介已关闭评论
4月 242018
 

一、nagios配置过程详解


1、nagios默认配置文件介绍
 nagios安装完毕后,默认的配置文件在/usr/local/nagios/etc目录下,每个文件或目录含义如下表所示:

 

2、配置文件之间的关系
 在nagios的配置过程中涉及到的几个定义有:主机、主机组,服务、服务组,联系人、联系人组,监控时间,监控命令等,从这些定义可以看出,nagios各个配置文件之间是互为关联,彼此引用的。
 成功配置出一台nagios监控系统,必须要弄清楚每个配置文件之间依赖与被依赖的关系,最重要的有四点:
 第一:定义监控哪些主机、主机组、服务和服务组
 第二:定义这个监控要用什么命令实现,
 第三:定义监控的时间段,
 第四:定义主机或服务出现问题时要通知的联系人和联系人组。

 

3、开始配置nagios
 为了能更清楚的说明问题,同时也为了维护方便,建议将nagios各个定义对象创建独立的配置文件:
 即为:
 创建hosts.cfg文件来定义主机和主机组
 创建services.cfg文件来定义服务
 用默认的contacts.cfg文件来定义联系人和联系人组
 用默认的commands.cfg文件来定义命令
 用默认的timeperiods.cfg来定义监控时间段
 用默认的templates.cfg文件作为资源引用文件

  (1)templates.cfg文件
 
 nagios主要用于监控主机资源以及服务,在nagios配置中称为对象,为了不必重复定义一些监控对象,Nagios引入了一个模板配置文件,将一些共性的属性定义成模板,以便于多次引用。这就是templates.cfg的作用。
 下面详细介绍下templates.cfg文件中每个参数的含义:

  1.  define contact{  
  2.         name                            generic-contact        #联系人名称,  
  3.         service_notification_period     24×7                   #当服务出现异常时,发送通知的时间段,这个时间段“7×24″在timeperiods.cfg文件中定义  
  4.         host_notification_period        24×7                   #当主机出现异常时,发送通知的时间段,这个时间段“7×24″在timeperiods.cfg文件中定义  
  5.         service_notification_options    w,u,c,r         #这个定义的是“通知可以被发出的情况”。w即warn,表示警告状态,u即unknown,表示不明状态,c即criticle,表示紧急状态,r即recover,表示恢复状态。也就是在服务出现警告状态、未知状态、紧急状态和重新恢复状态时都发送通知给使用者。  
  6.         host_notification_options       d,u,r         #定义主机在什么状态下需要发送通知给使用者,d即down,表示宕机状态,u即unreachable,表示不可到达状态,r即recovery,表示重新恢复状态。  
  7.         service_notification_commands   notify-service-by-email  #服务故障时,发送通知的方式,可以是邮件和短信,这里发送的方式是邮件,其中“notify-service-by-email”在commands.cfg文件中定义。  
  8.         host_notification_commands      notify-host-by-email     #主机故障时,发送通知的方式,可以是邮件和短信,这里发送的方式是邮件,其中“notify-host-by-email”在commands.cfg文件中定义。  
  9.         register                        0  
  10.         }  
  11.  define host{   
  12.         name                            generic-host    #主机名称,这里的主机名,并不是直接对应到真正机器的主机名,乃是对应到在主机配置文件里所设定的主机名。  
  13.         notifications_enabled           1              
  14.         event_handler_enabled           1               
  15.         flap_detection_enabled          1               
  16.         failure_prediction_enabled      1             
  17.         process_perf_data               1              
  18.         retain_status_information       1             
  19.         retain_nonstatus_information    1                
  20.         notification_period             24×7           #指定“发送通知”的时间段,也就是可以在什么时候发送通知给使用者。  
  21.         register                        0                
  22.         }  
  23.  
  24. define host{  
  25.         name                            linux-server    #主机名称  
  26.         use                             generic-host    #use表示引用,也就是将主机generic-host的所有属性引用到linux-server中来,在nagios配置中,很多情况下会用到引用。  
  27.         check_period                    24×7            #这里的check_period告诉nagios检查主机的时间段  
  28.         check_interval                  5                #nagios对主机的检查时间间隔,这里是5分钟。  
  29.         retry_interval                  1               #重试检查时间间隔,单位是分钟。  
  30.         max_check_attempts              10               #nagios对主机的最大检查次数,也就是nagios在检查发现某主机异常时,并不马上判断为异常状况,而是多试几次,因为有可能只是一时网络太拥挤,或是一些其他原因,让主机受到了一点影响,这里的10就是最多试10次的意思。  
  31.         check_command                   check-host-alive  #指定检查主机状态的命令,其中“check-host-alive”在commands.cfg文件中定义。  
  32.         notification_period             workhours      #主机故障时,发送通知的时间范围,其中“workhours”在timeperiods.cfg中进行了定义,下面会陆续讲到。  
  33.                                                          
  34.         notification_interval           120            #在主机出现异常后,故障一直没有解决,nagios再次对使用者发出通知的时间。单位是分钟。如果你觉得,所有的事件只需要一次通知就够了,可以把这里的选项设为0  
  35.         notification_options            d,u,r          #定义主机在什么状态下可以发送通知给使用者,d即down,表示宕机状态,u即unreachable,表示不可到达状态,r即recovery,表示重新恢复状态。  
  36.         contact_groups                  admins         #指定联系人组,这个“admins”在contacts.cfg文件中定义。  
  37.         register                        0  
  38.         }  
  39.  
  40. define service{  
  41.         name                            generic-service   #定义一个服务名称  
  42.         active_checks_enabled           1     
  43.         passive_checks_enabled          1      
  44.         parallelize_check                1      
  45.         obsess_over_service             1      
  46.         check_freshness                0  
  47.         notifications_enabled            1                 
  48.         event_handler_enabled           1                   
  49.         flap_detection_enabled           1                    
  50.         failure_prediction_enabled        1                   
  51.         process_perf_data               1                   
  52.         retain_status_information       1                     
  53.         retain_nonstatus_information    1                        
  54.         is_volatile                     0   
  55.         check_period                    24×7      #这里的check_period告诉nagios检查服务的时间段。              
  56.         max_check_attempts              3         #nagios对服务的最大检查次数。           
  57.         normal_check_interval           10       #此选项是用来设置服务检查时间间隔,也就是说,nagios这一次检查和下一次检查之间所隔的时间,这里是10分钟。   
  58.         retry_check_interval            2        #重试检查时间间隔,单位是分钟。            
  59.         contact_groups                  admins   #指定联系人组,同上。              
  60.         notification_options            w,u,c,r  #这个定义的是“通知可以被发出的情况”。w即warn,表示警告状态,u即unknown,表示不明状态,c即criticle,表示紧急状态,r即recover,表示恢复状态。也就是在服务出现警告状态、未知状态、紧急状态和重新恢复后都发送通知给使用者。  
  61.         notification_interval           60       #在服务出现异常后,故障一直没有解决,nagios再次对使用者发出通知的时间。单位是分钟。如果你认为,所有的事件只需要一次通知就够了,可以把这里的选项设为0。  
  62.         notification_period             24×7     #指定“发送通知”的时间段,也就是可以在什么时候发送通知给使用者。               
  63.          register                        0                       
  64.         }  
  65.  


(2)resource.cfg文件

 resource.cfg是nagios的变量定义文件,文件内容只有一行:
 

  1. $USER1$=/usr/local/nagios/libexec 
 其中,变量$USER1$指定了安装nagios插件的路径,如果把插件安装在了其它路径,只需在这里进行修改即可。需要注意的是,变量必须先定义,然后才能在其它配置文件中进行引用。

(3)理解Nagios宏及其工作机制

Nagios配置非常灵活,继承和引用是一大特征,另一个重要特征就是可以在命令行的定义里使用宏,通过定义宏,nagios可以灵活的获取主机、服务和其它对象的信息。
宏的工作机制
在执行命令之前,nagios将对命令里的每个宏替换成它们应当取得的值。这种宏替换发生在Nagios执行各种类型的宏时候。例如主机和服务的检测、通知、事件处理等。
 

宏的分类:
默认宏、按需而成的宏、用户自定制宏等。
 

默认宏
主机IP地址宏
当在命令定义中使用主机或服务宏时,宏将要执行所用的值指向主机或服务所带有值。看下面这个例子,假定在check_ping命令定义里使用了一个主机对象,例如这样:

  1. define host{  
  2.   host_name               ixdba  
  3.   address   192.168.12.246  
  4.   check_command               check_ping  
  5.   …  
  6.   }  
  7. define command{  
  8.   command_name    check_ping  
  9.   command_line    /usr/local/nagios/libexec/check_ping -H $HOSTADDRESS$ -w 100.0,90% -c 200.0,60%  
  10.   } 


那么执行这个主机检测命令时展开并最终执行的将是这样的:

  1. /usr/local/nagios/libexec/check_ping -H 192.168.12.246 -w 100.0,90% -c 200.0,60% 


命令参数宏
同样你可以向命令传递参数,这样可以保证命令定义更具通用性。参数指定在对象(象主机或服务)中定义,用一个“!”来分隔,例如这样:

  1. define service{  
  2.   host_name  linuxbox  
  3.   service_description PING  
  4.   check_command              check_ping!200.0,80%!400.0,40%  
  5.   …  
  6.   } 


在上例中,服务的检测命令中含有两个参数(请参考$ARGn$宏),而$ARG1$宏将是”200.0,80%”,同时$ARG2$将是”400.0,40%”(都不带引号)。假定使用之前的主机定义并这样来定义你的check_ping命令:

  1. define command{  
  2.   command_name    check_ping  
  3.   command_line    /usr/local/nagios/libexec/check_ping -H $HOSTADDRESS$ -w $ARG1$ -c $ARG2$  
  4.   } 


那么对于服务的检测命令最终将是这样子的:

  1. /usr/local/nagios/libexec/check_ping -H 192.168.12.246 -w 200.0,80% -c 400.0,40% 

 

Nagios可用的全部的宏

主机宏
$HOSTNAME$  主机简称(如”web”),取自于主机定义里的host_name域
$HOSTADDRESS$  主机地址。取自于主机定义里的address域
服务宏
$SERVICESTATE$ 服务状态描述,有w,u,c
$SERVICEDESC$   对当前服务的描述  
联系人宏
$CONTACTNAME$   表示联系人,在联系人文件中定义
通知宏
$NOTIFICATIONTYPE$    返回下面信息:(“PROBLEM”, “RECOVERY”, “ACKNOWLEDGEMENT”, “FLAPPINGSTART”, “FLAPPINGSTOP”, “FLAPPINGDISABLED”, “DOWNTIMESTART”, “DOWNTIMEEND”, or “DOWNTIMECANCELLED”).
日期/时间宏
$LONGDATETIME$  当前的日期/时间戳
文件宏
$LOGFILE$  日志文件的保存位置。
$MAINCONFIGFILE$  主配置文件的保存位置。
其他宏
$ADMINEMAIL$  全局的管理员EMail地址
$ARGn$  指向第n个命令传递参数(通知、事件处理、服务检测等)。Nagios支持最多32个参数宏

 

(4)commands.cfg文件
 此文件默认是存在的,无需修改即可使用,当然如果有新的命令需要加入时,在此文件进行添加即可。这里并未列出文件的所有内容,仅仅介绍了配置中用到的一些命令。 

  1. #下面是notify-host-by-email命令的定义  
  2. define command{  
  3.         command_name    notify-host-by-email    #命令名称,即定义了一个主机异常时发送邮件的命令。  
  4.         command_line    /usr/bin/printf “%b” “***** Nagios *****\n\nNotification Type: $NOTIFICATIONTYPE$\nHost: $HOSTNAME$\nState: $HOSTSTATE$\nAddress: $HOSTADDRESS$\nInfo: $HOSTOUTPUT$\n\nDate/Time: $LONGDATETIME$\n” | /bin/mail -s “** $NOTIFICATIONTYPE$ Host Alert: $HOSTNAME$ is $HOSTSTATE$ **” $CONTACTEMAIL$    #命令具体的执行方式,“-H $HOSTADDRESS$” 是定义目标主机的地址,这个地址在hosts.cfg文件中定义了。  
  5.         }  
  6. #下面是notify-host-by-email命令的定义  
  7. define command{  
  8.         command_name    notify-service-by-email   #命令名称,即定义了一个服务异常时发送邮件的命令  
  9.         command_line    /usr/bin/printf “%b” “***** Nagios *****\n\nNotification Type: $NOTIFICATIONTYPE$\n\nService: $SERVICEDESC$\nHost: $HOSTALIAS$\nAddress: $HOSTADDRESS$\nState: $SERVICESTATE$\n\nDate/Time: $LONGDATETIME$\n\nAdditional Info:\n\n$SERVICEOUTPUT$” | /bin/mail -s “** $NOTIFICATIONTYPE$ Service Alert: $HOSTALIAS$/$SERVICEDESC$ is $SERVICESTATE$ **” $CONTACTEMAIL$  
  10.         }  
  11.  
  12. #下面是notify-host-by-email命令的定义  
  13.  define command{  
  14.         command_name    check-host-alive   #命令名称,用来检测主机状态。  
  15.        command_line    $USER1$/check_ping -H $HOSTADDRESS$ -w 3000.0,80% -c 5000.0,100% -p 5     #这里的变量$USER1$在resource.cfg文件中进行定义,即$USER1$=/usr/local/nagios/libexec  
  16. ,那么check_ping的完整路径为/usr/local/nagios/libexec/check_ping。 “-w 3000.0,80%”中“-w”说明后面的一对值对应的是“WARNING”状态,“80%”是其临界值。“-c 5000.0,100%”中“-c”说明后面的一对值对应的是“CRITICAL”,“100%”是其临界值。“-p 1”说明每次探测发送一个包。  
  17.         }  
  18. #下面是notify-host-by-email命令的定义  
  19.  define command{  
  20.         command_name    check_ftp  
  21.         command_line    $USER1$/check_ftp -H $HOSTADDRESS$ $ARG1$    #$ARG1$是指在调用这个命令的时候,命令后面的第一个参数。  
  22.         }  
  23. #下面是check_http命令的定义  
  24.  define command{  
  25.         command_name    check_http  
  26.         command_line    $USER1$/check_http -I $HOSTADDRESS$ $ARG1$  
  27.         }  
  28. #下面是check_ssh命令的定义  
  29.  define command{  
  30.         command_name    check_ssh  
  31.         command_line    $USER1$/check_ssh $ARG1$ $HOSTADDRESS$  
  32.         }  
  33.  


(5) hosts.cfg文件
 此文件默认不存在,需要手动创建,hosts.cfg主要用来指定被监控的主机地址以及相关属性信息,一个配置好的实例如下:

  1. define host{  
  2.         use                     linux-server  #引用主机linux-server的属性信息,linux-server主机在templates.cfg文件中进行了定义。  
  3.         host_name               web    #主机名  
  4.         alias                    ixdba-web  #主机别名  
  5.         address                 192.168.12.251  #被监控的主机地址,这个地址可以是ip,也可以是域名。  
  6.         }  
  7. ?  
  8.  define host{  
  9.         use                     linux-server  
  10.         host_name              mysql  
  11.         alias                    ixdba-mysql  
  12.         address                 192.168.12.237  
  13.         }  
  14. ?  
  15.  define hostgroup{      #定义一个主机组  
  16.  hostgroup_name  sa-servers        #主机组名称,可以随意指定。  
  17.  alias           sa servers    #主机组别名  
  18.  members         web,mysql   #主机组成员,其中“web”、“mysql”就是上面定义的两个主机。  
  19.  }  
  20.  


(6) services.cfg文件
 此文件默认也不存在,需要手动创建,services.cfg文件主要用于定义监控的服务和主机资源,例如监控http服务、ftp服务、主机磁盘空间、主机系统负载等等。

  1. #################  ixdba   web  #####################  
  2.  define service{  
  3.         use                             local-service  #引用local-service服务的属性值,local-service在templates.cfg文件中进行了定义。  
  4.         host_name                       web  #指定要监控哪个主机上的服务,“web”在hosts.cfg文件中进行了定义。  
  5.         service_description             PING  #对监控服务内容的描述,以供维护人员参考。  
  6.         check_command                   check_ping!100.0,20%!500.0,60% #指定检查的命令,check_ping命令在commands.cfg中定义,后跟两个参数,命令与参数间用!分割。         
  7.         }  
  8.  
  9.  define service{  
  10.         use                             local-service  
  11.         host_name                       web  
  12.         service_description              SSH  
  13.         check_command                  check_ssh    # check_ssh命令也在commands.cfg中定义。  
  14.         }  
  15.  
  16.  define service{  
  17.         use                             local-service  
  18.         host_name                       web  
  19.         service_description              SSHD  
  20.         check_command                  check_tcp!22  
  21.         }  
  22.  


(7) contacts.cfg文件
 contacts.cfg是一个定义联系人和联系人组的配置文件,当监控的主机或者服务出现故障,nagios会通过指定的通知方式(邮件或者短信)将信息发给这里指定的联系人或者使用者。

  1. define contact{  
  2.         contact_name                    sasystem  #联系人名称  
  3.         use                             generic-contact #引用generic-contact的属性信息,其中“generic-contact”在templates.cfg文件中进行定义  
  4.         alias                           sa-system  #联系人别名  
  5.         email                          ixdba@126.com  #联系人的邮件地址  
  6.         }  
  7. define contactgroup {  
  8.       contactgroup_name    admins #联系人组名称  
  9.       alias                system administrator group #联系人组描述  
  10.       members              sasystem  #联系人组成员,其中“sasystem”就是上面定义的联系人  
  11. }  
  12.  


(8) timeperiods.cfg文件
 此文件只要用于定义监控的时间段,下面是一个配置好的实例:

  1. #下面是定义一个名为24×7的时间段,即监控所有时间段  
  2. define timeperiod{  
  3.         timeperiod_name 24×7     
  4.         alias           24 Hours A Day, 7 Days A Week  
  5.         sunday          00:00-24:00  
  6.         monday          00:00-24:00  
  7.         tuesday         00:00-24:00  
  8.         wednesday       00:00-24:00  
  9.         thursday        00:00-24:00  
  10.         friday          00:00-24:00  
  11.         saturday        00:00-24:00  
  12.         }  
  13. #下面是定义一个名为workhours的时间段,即工作时间段。  
  14. define timeperiod{  
  15.         timeperiod_name workhours   
  16.         alias           Normal Work Hours  
  17.         monday          09:00-17:00  
  18.         tuesday         09:00-17:00  
  19.         wednesday       09:00-17:00  
  20.         thursday        09:00-17:00  
  21.         friday          09:00-17:00  
  22.         }  
  23.  


(9) cgi.cfg文件
 此文件用来控制相关cgi脚本,如果想在nagios的web监控界面执行cgi脚本,例如重启nagios进程、关闭nagios通知、停止nagios主机检测等,这时就需要配置cgi.cfg文件了。
 由于nagios的web监控界面验证用户为ixdba,所以只需在cgi.cfg文件中添加此用户的执行权限就可以了,需要修改的配置信息如下:

  1. default_user_name=ixdba 
  2. authorized_for_system_information=nagiosadmin,ixdba  
  3. authorized_for_configuration_information=nagiosadmin,ixdba  
  4. authorized_for_system_commands=ixdba 
  5. authorized_for_all_services=nagiosadmin,ixdba  
  6. authorized_for_all_hosts=nagiosadmin,ixdba  
  7. authorized_for_all_service_commands=nagiosadmin,ixdba  
  8. authorized_for_all_host_commands=nagiosadmin,ixdba  
  9.  

(10) nagios.cfg文件
  Nagios.cfg默认的路径为/usr/local/nagios/etc/nagios.cfg,是nagios的核心配置文件,所有的对象配置文件都必须在这个文件中进行定义才能发挥其作用,这里只需将对象配置文件在Nagios.cfg文件中进行引用即可。

  1. log_file=/usr/local/nagios/var/nagios.log  
  2. “log_file”变量用来定义nagios日志文件的路径。  
  3. cfg_file=/usr/local/nagios/etc/hosts.cfg  
  4. cfg_file=/usr/local/nagios/etc/services.cfg  
  5. cfg_file=/usr/local/nagios/etc/commands.cfg  
  6. cfg_file=/usr/local/nagios/etc/contacts.cfg  
  7. cfg_file=/usr/local/nagios/etc/timeperiods.cfg  
  8. cfg_file=/usr/local/nagios/etc/templates.cfg  
  9.  “cfg_file”变量用来引用对象配置文件,如果有更多的对象配置文件,在这里依次添加即可。  
  10. object_cache_file=/usr/local/nagios/var/objects.cache  
  11. 该变量用于指定一个“所有对象配置文件”的副本文件,或者叫对象缓冲文件  
  12.  
  13. resource_file=/usr/local/nagios/etc/resource.cfg  
  14. 该变量用于指定nagios资源文件的路径,可以在Nagios.cfg中定义多个资源文件。  
  15. status_file=/usr/local/nagios/var/status.dat  
  16. 该变量用于定义一个状态文件,此文件用于保存nagios的当前状态、注释和宕机信息等。  
  17. status_update_interval=10 
  18.  该变量用于定义状态文件(即status.dat)的更新时间间隔,单位是秒,最小更新间隔是1秒。  
  19. nagios_user=nagios  
  20. 该变量指定了Nagios进程使用哪个用户运行。  
  21. nagios_group=nagios  
  22.  该变量用于指定Nagios使用哪个用户组运行。  
  23. check_external_commands=1 
  24.  该变量用于设置是否允许nagios在web监控界面运行cgi命令,也就是是否允许nagios在web界面下执行重启nagios、停止主机/服务检查等操作。“1”为运行,“0”为不允许。  
  25. command_check_interval=2 
  26.  该变量用于设置nagios对外部命令检测的时间间隔,如果指定了一个数字加一个”s”(如10s),那么外部检测命令的间隔是这个数值以秒为单位的时间间隔。如果没有用”s”,那么外部检测命令的间隔是以这个数值的“时间单位”的时间间隔。  
  27. interval_length=60 
  28.  该变量指定了nagios的时间单位,默认值是60秒,也就是1分钟,即在nagios配置中所有的时间单位都是分钟。  

==================================================================================================================================================================================

主配置文件 nagios.cfg 需要更改的地方:
 #cfg_file=/usr/local/nagios/etc/objects/localhost.cfg
 interval_length=1 ; 间隔时间基准由 60s 改为 1s
 command_check_interval=10s ; 命令检查时间间隔,-1 表示尽可能频繁的进行检查
 date_format=iso8601 ; 日期格式
 objects/contacts.cfg 用来定义联系人:

define contact {
 contact_name sa
 alias System Administrator
 service_notification_period 24×7
 host_notification_period 24×7
 service_notification_options w,u,c,r
 host_notification_options d,u,r
 service_notification_commands notify-service-by-email
 host_notification_commands notify-host-by-email
 email admin@test.com
 } 
定义联系人组
define contactgroup {
 contactgroup_name admins
 alias Administrator Group
 members sa    ; 添加其它联系人用 “,” 分隔
 } 
主机监控的配置
define host {
 host_name host_name    ; 简短的主机名称。
 alias alias    ; 别名,可以更详细的说明主机。
 address address    ; IP 地址,也可以写主机名。如果不定义这个值, nagio 将会用 host_name 去寻找主机。
 parents host_names    ; 上一节点的名称,也就是指从 nagios 服务器到被监控主机之间经过的节点,可以是路由器、交换机、主机等等。
 hostgroups hostgroup_names    ; 简短的主机组名称。
 check_command command_name    ; 检查命令的简短名称,如果此项留空, nagios 将不会去判断主机是否 alive 。
 max_check_attempts 整数    ; 当检查命令的返回值不是 “OK” 时,重试的次数。
 check_interval 数字    ; 循环检查的间隔时间。
 active_checks_enabled [0/1]    ; 是否启用 “active_checks”
 passive_checks_enabled [0/1]    ; 是否启用 “passive_checks” ,及“被动检查”
 check_period timeperiod_name    ; 检测时间段简短名称,这只是个名称,具体的时间段要写在其他的配置文件中。
 obsess_over_host [0/1]    ; 是否启用主机操作系统探测。
 check_freshness [0/1]    ; 是否启用 freshness 检查。freshness 检查是对于启用被动检查模式的主机而言的,其作用是定期检查主机报告的状态信息,如果该状态信息已经过期,freshness 将会强制做主机检查。
 freshness_threshold 数字     ; fressness 的临界值,单位为秒。 如果定义为 “0″ ,则为自动定义。
 event_handler command_name    ; 当主机发生状态改变时,采用的处理命令的简短的名字(可以在 commands.cfg 中对其定义)
 event_handler_enabled [0/1]    ; 是否启用 event_handler
 low_flap_threshold 数字    ; 抖动的下限值。抖动,即在一段时间内,主机(或服务)的状态值频繁的发生变化。
 high_flap_threshold 数字   ; 抖动的上限值。
 flap_detection_enabled [0/1]    ; 是否启用抖动检查。
 process_perf_data [0/1]    ; 是否启用 processing of performance data
 retain_status_information [0/1]    ; 程序重启时,是否保持主机状态相关的信息。
 retain_nonstatus_information [0/1]    ; 程序重启时,是否保持主机状态无关的信息。
 contact_groups contact_groups    ; 联系人组,在此组中的联系人都会收到主机的提醒信息。
 notification_interval 整数    ; 重复发送提醒信息的最短间隔时间。默认间隔时间是 “60″ 分钟。如果这个值设置为 “0″ ,将不会发送重复提醒。
 notification_period timeperiod_name   ; 发送提醒的时间段。非常重要的主机(服务)定义为 24×7 ,一般的主机(服务)就定义为上班时间。如果不在定义的时间段内,无论发生什么问题,都不会发送提醒。
 notification_options [d,u,r,f]    ; 发送提醒包括的情况: d = 状态为 DOWN , u = 状态为 UNREACHABLE , r = 状态恢复为 OK , f = flapping
 notifications_enabled [0/1]    ; 是否开启提醒功能。”1″ 为开启,”0″ 为禁用。一般,这个选项会在主配置文件 (nagios.cfg) 中定义,效果相同。
 stalking_options [o,d,u]    ; 持续状态检测参数,o = 持续的 UP 状态 , d = 持续的 DOWN 状态 , u = 持续的 UNREACHABLE 状态
 } 
服务监控的配置

define service {
 host_name host_name
 service_description service_description
 servicegroups servicegroup_names
 is_volatile [0/1]
 check_command command_name
 max_check_attempts
 normal_check_interval
 retry_check_interval
 active_checks_enabled [0/1]
 passive_checks_enabled [0/1]
 check_period timeperiod_name
 parallelize_check [0/1]
 obsess_over_service [0/1]
 check_freshness [0/1]
 freshness_threshold
 event_handler command_name
 event_handler_enabled [0/1]
 low_flap_threshold
 high_flap_threshold
 flap_detection_enabled [0/1]
 process_perf_data [0/1]
 retain_status_information [0/1]
 retain_nonstatus_information [0/1]
 notification_interval
 notification_period timeperiod_name n
 otification_options [w,u,c,r,f]
 notifications_enabled [0/1]
 contact_groups contact_groups
 stalking_options [o,w,u,c]
 } 
服务监控的配置和主机监控的配置较为相似,就不一一说明了。 
间隔时间的计算方法为:
 normal_check_interval x interval_length 秒
 retry_check_interval x interval_length 秒
 notification_interval x interval_length 秒
 
主机监控配置的例子
define host {
 host_name web1
 alias web1
 address 192.168.0.101
 contact_groups admins
 check_command check-host-alive
 max_check_attempts 5
 notification_interval 0
 notification_period 24×7
 notification_options d,u,r
 } 
对主机 web1 进行 24×7 的监控,默认会每 10 秒检查一次状态,累计五次失败就发送提醒,并且不再重复发送提醒。
 服务监控配置的例子 
define service {
 host_name web1
 service_description check_http
 check_period 24×7
 max_check_attempts 3
 normal_check_interval 30
 contact_groups admins
 retry_check_interval 15
 notification_interval 3600
 notification_period 24×7
 notification_options w,u,c,r
 check_command check_http
 }
 
配置解释: 24×7 监控 web1 主机上的 HTTP 服务,检查间隔为 30 秒, 检查失败后每 15 秒再进行一次检查,累计三次失败就认定是故障并发送提醒。
 联系人组是 admins 。提醒后恢复到 30 秒一次的 normal_check_interval 检查。如果服务仍然没有被恢复,每个小时发送一次提醒。
 如果要检测其他服务,例如,要检查 ssh 服务是否开启,更改如下两行:
 service_description check_ssh
 check_command check_ssh 
为方便管理,对配置文件的分布做了如下修改:
 nagios.cfg 中增加了:
 cfg_dir=/usr/local/nagios/etc/hosts
 cfg_dir=/usr/local/nagios/etc/services 
在 hosts 目录中,为不同类型的主机创建了配置文件,如: app.cfg cache.cfg mysql.cfg web.cfg
 并创建了 hostgroup.cfg 文件对主机进行分组,如:

define hostgroup {
 hostgroup_name app-hosts
 alias APP Hosts
 members app1,app2
 } 
在 services 目录中创建了各种服务的配置文件,如: disk.cfg http.cfg load.cfg mysql.cfg
 并创建了 servicegroup.cfg 文件对服务进行分组,如:

define servicegroup {
 servicegroup_name disk
 alias DISK
 members cache1,check_disk,cache2,check_disk

 } 

转自: https://blog.csdn.net/lin_fs/article/details/8555960