限制ip接口案例

为什么要开细节类

因为有很多东西，很细微，但又很实用。就会放在细节类。该类的目的是做个记录，既然简单。

限制ip接口案例

场景

需要针对相同ip用户每分访问接口次数的做限制，防止用户恶意刷。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * 接口 ip 限制
 * @param $miniutes 分钟数
 * @param $times 次数
 * @param $api 接口唯一标识
 * @return bool
 */
public function apiIpLimit($miniutes, $times, $api)
{
    $ip = Request::getClientIP(); //获取用户ip

    if ($ip) {
        $key = $api . "_" . $ip;

        $num = Yii::$app->cookie->get($key);
        $num = $num ? $num + 1 : 1; //请求次数加1
        if ($num > $times) {
            Yii::getLogger()->log($key . " exceed limit", Logger::LEVEL_ERROR);
            return false; //超过限制次数直接返回，不重置过期时间
        }

        Yii::$app->cookie->set($key, $num, $miniutes * 60); //未超过限制次数，更新访问次数，并重置过期时间为一分钟
    }

    return true;
}

解析

情景

假设每分钟限制8次请求

代码逻辑是否符合需求

上面的代码案例并不是完全依照每分钟限制8次请求逻辑处理，因为有重置过期时间。

假设第6，7，8次请求都间隔了40s。按逻辑，第6次和第8次中间间隔了80s，超过一分钟了，但因为访问接口，未超过限制次数时会重置过期时间为60s的因素，第6次访问和第8次访问被累加在同一个次数累计中。

代码合理性

从合理性上，我觉得是合理的。但逻辑解释应该是相同ip距离上一次访问时间不超过一分钟，计入次数累计，当次数累计超过限制次数将会返回错误，时间1min

当然，如果要按目前逻辑实现也很简单，可以存储值num_day(累计次数+当天日期(最小单位:天))，然后重置的时间设置为当前时间戳-第一次的时间戳。

优化点

首先ip这块用户可以通过vpn等手段切换不同ip。

其次，限制次数是设置在cookie用户是可以删除的。

建议：限制用户每天可以请求多少次，记录在redis之类的服务端缓存。

限制用户每天可以请求多少次

检验

1
2
3
4
// 邀请邮件 校验: 每天(utc时区)限制50封
if ($this->getApiRequestLimitByDay(50, 'bizInviteEmail') === false) {
    Response::echoResult(ErrCode::$ACCOUNT_LIMIT_ERR);
}

累计次数

1
$this->setApiRequestLimitByDay('bizInviteEmail', $accountId); //发送邮件后更新用户当天发邮件次数

方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/**
 * 获取接口是否超出每日访问次数限制
 * @param $times 次数
 * @param $api 限制内容唯一标识
 * @param string $accountId 用户主账号id
 * @return bool
 */
public function getApiRequestLimitByDay($times, $api, $accountId = "")
{
    if(empty($accountId)) {
        $accountId = \Yii::$app->bizUser->accountId;
    }

    if ($accountId) {
        $day = date('Y_m_d',time());
        $key = $api . "_" . $accountId . "_" . $day;

        $redis = Factory::getUserRedisClient();
        $num = $redis->get($key);
        $num = $num ? $num + 1 : 1;

        if ($num > $times) {
            Yii::getLogger()->log($key . " exceed limit", Logger::LEVEL_ERROR);
            return false;
        }
    }

    return true;
}

/**
 * 更新(累加)接口每日访问次数
 * @param $api 限制内容唯一标识
 * @param string $accountId 用户主账号id
 */
public function setApiRequestLimitByDay($api, $accountId = "")
{
    if(empty($accountId)) {
        $accountId = \Yii::$app->bizUser->accountId;
    }

    if ($accountId) {
        $day = date('Y_m_d',time());
        $key = $api . "_" . $accountId . "_" . $day;

        $redis = Factory::getUserRedisClient();
        $num = $redis->get($key);
        $num = $num ? $num + 1 : 1;

        try {
            $redis->setex($key, 86400, $num); //保存一天后过期
        } catch (\Exception $e) {
            LogService::logError("set $ownerId $key exception : " . $e->getMessage());
        }
    }
}

展开全文 >>

Docker常用操作命令大全

环境

Linux Centos7

docker进程相关命令

  • systemctl start docker #启动docker服务
  • systemctl stop docker #停止docker服务
  • systemctl restart docker#重启docker服务
  • systemctl status docker #查看docker服务状态
  • systemctl enable docker#设置开机启动服务

docker容器管理命令

docker run -d --name {your_name} {image_name} # 运行容器

参数说明：

-i：以交互模式运行容器，通常与 -t 同时使用。加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭。

-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用。

-d：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec 进入容器。退出后，容器不会关闭。

-it 创建的容器一般称为交互式容器；

-id 创建的容器一般称为守护式容器。

–name：为创建的容器命名。

-p：指定容器的端口，格式为：主机(宿主)端口:容器端口

-P(大写): 随机端口映射，容器内部端口随机映射到主机的端口

–volume , -v: 绑定一个卷,格式:宿主机目录/文件:容器内目录/文件

​ 目录必须是绝对路径,如果目录不存在，会自动创建,可以挂载多个数据卷。

1
2
3
4
5
例子：
docker run -p 80:80 -v /data:/data -d nginx:latest

绑定容器的 8080 端口，并将其映射到本地主机 127.0.0.1 的 80 端口上。
$ docker run -p 127.0.0.1:80:8080/tcp ubuntu bash
  • docker ps # 查看正在运行的容器
  • docker ps -s -a #查看当前所有容器
  • docker stop {容器ID} #停止容器
  • docker restart {容器ID} #重启容器
  • docker kill {容器ID} #杀死容器
  • docker rm -f {容器ID} #删除已经停止的容器(这个会彻底释放内存)

如果容器是运行状态则删除失败，需要停止容器才能删除。

docker镜像管理命令

  • docker images #查看当前机器的所有镜像

    参数：

    -a/–all 列出所有镜像

    -q/–quiet 只显示镜像的id

  • docker images –q # 查看所用镜像的id

  • docker search {镜像名称} #搜索镜像，网络中查找需要的镜像

    $docker search redis

    查找stars大于3000的镜像：docker search mysql --filter=stars=3000

  • docker pull {镜像名称}[:tag] #从Docker仓库拉取镜像，名称:版本号

​ $docker pull mysql 或$docker pull mysql:5.7

  • docker push {镜像名称} #推送镜像

  • docker rmi [-f] {镜像名称/镜像id} #删除本地机器的镜像

  • docker rmi [-f] {镜像id} {镜像id} {镜像id} #删除多个本地机器的镜像

  • docker rmi [-f] docker images -q #删除所有本地镜像

  • docker tag 镜像名称:tag 镜像名称:tag #为一个镜像打tag

    将镜像ubuntu:15.10标记为 runoob/ubuntu:v3 镜像

    docker tag ubuntu:15.10 runoob/ubuntu:v3

    查看: docker images runoob/ubuntu:v3

  • docker save {image_name} > {new_image_name}.tar #镜像打包成一个tar包

  • docker load < {image_name}.tar #解压一个镜像tar包

查看日志信息

  • docker logs -f {容器ID} #查看容器日志
  • docker info #查看docker服务的信息
  • docker inspect {容器ID} # 获取镜像的元信息，详细信息

查看进程

$ docker top f42ae22e4b72

与容器交互的命令

进入正在运行的容器

1
docker exec -it 容器ID或者容器名 /bin/bash

exec的意思是在容器中运行⼀个命令。/bin/bash是固有写法，作用是因为docker后台必须运行一个进程，否则容器就会退出，在这里表示启动容器后启动 bash。

-d :分离模式: 在后台运行

-i :即使没有附加也保持STDIN 打开

-t :分配一个伪终端

退出容器

exit #退出也关闭容器;

Ctrl+P+Q #退出不关闭容器

拷贝文件

docker cp 主机文件路径 容器ID或容器名:容器路径 #宿主机文件拷贝到容器中

docker cp 容器ID或容器名:容器路径 主机文件路径 #容器文件拷贝到宿主机中

原文链接：

docker命令记不住？docker常用操作命令大全

Docker常用命令

Docker 命令大全

展开全文 >>

charles手机端捕获数据

推荐一款自己常用的捕获手机端数据工具:charles

注意:关于安卓7.0版本以上charles无法抓取https包的问题,这个因为测试都是公司的包，所以安卓开发那边会做相应处理打包，就不会出现问题了。

关于Charles的安装，Charles给手机链接代理，安装证书，安卓手机抓包的连接，以及配置 这篇文章写得很不错的。

常用的点

在处理好PC端的charles的下载，安装，证书之类后。

手机连接与电脑同一网络下的WIFI,手动设置代理，主机名charles:Help->Local IP Addresses,端口名charles:Proxy->Proxy Settings->Port。

连接成功后，其实就可以捕获数据了。但是https的数据会显示错误，这时候就需要下载证书了。

手机浏览器下载证书链接:http://chls.pro/ssl,下载完后。让手机信任证书，例如:"指纹与密码-其他安装选项-从存储装置安装"操作信任，当然不同手机操作信任的路径不一定相同。

Charles抓包postman

因为有很多测试再postman上面测试，那么如何让postman上面的数据被charles捕获，看下面这篇文章。

Charles抓包postman

要想postman请求走charles，那么需要手动在postman设置代理，如下图

Charles Android 抓包失败(未实践，因为内部有专门可捕捉包)

app抓不到包之将证书安装到系统证书中

Charles Android 抓包失败SSLHandshake: Received fatal alert: certificate_unknown

展开全文 >>

Go 控制结构for循环loop

for循环是编程语言中一种循环语句，for 是 Go 语言唯一的循环语句.Go 语言中并没有其他语言比如 C 语言中的 while 和 do while 循环.

for循环

1
2
for initialisation; condition; post {  
}

这是典型的 for 循环三个表达式,第一个为初始化表达式或赋值语句;第二个为循环条件判定表达式;第三个为循环变量修正表达式,即此处的 post。

示例:

1
2
3
4
5
6
7
package main  
import "fmt"  
func main() {  
   for a := 0; a < 12; a++ {  
      fmt.Print(a,"\n")  
   }  
}

 

for嵌套

Go 语言允许用户在循环内使用循环.接下来我们将为大家介绍嵌套循环的使用.

以下实例使用循环嵌套来输出 2 到 100 间的素数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var i, j int

   for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break; // 如果发现因子,则不是素数
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d  是素数\n", i);
      }
   }  
}

break

break 语句用于在完成正常执行之前突然终止 for 循环,之后程序将会在 for 循环下一行代码开始执行。简单说就是整个for循环都结束了。

continue

continue 语句用来跳出 for 循环中当前循环.在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行.循环体会在一下次循环中继续执行。简单说就是for循环当前对应值的循环体内容终止执行，但for循环会继续匹配下一个值。

goto

Go 语言的 goto 语句可以无条件地转移到过程中指定的行.

goto 语句通常与条件语句配合使用.可用来实现条件转移, 构成循环,跳出循环体等功能.

但是,在结构化程序设计中一般不主张使用 goto 语句, 以免造成程序流程的混乱,使理解和调试程序都产生困难.

直接看示例：

在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++     
   }  
}

解析:

1
2
3
4
5
6
7
8
9
10
11
goto 和 LOOP配合使用在for循环中是比较经典的案例。上面的例子，a=a+1后a=15,跳转到LOOP处,for循环条件判断位置进行判断。
结果:
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

但是，语法:

1
2
3
4
goto label;
..
.
label: statement;

说明，LOOP你可以随意变换其他值(比如A、LO…)。下面也是一种使用例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto A
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++
   }

   A : fmt.Println("对，就是你")
}

结果:

1
2
3
4
5
6
7
8
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
对，就是你

//没错，跳到A执行后，for循环终止了。

展开全文 >>

GO 控制结构if-else

简单例子:

1
2
3
4
5
6
7
if condition1 {
	// do something	
} else if condition2 {
	// do something else	
} else {
	// catch-all or default
}

注意:

1.即使当代码块之间只有一条语句时,大括号也不可被省略。

2.关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行

1
2
3
4
if x{
}
else {	// 无效的
}

 

使用方式

当 if 结构内有 break,continue,goto 或者 return 语句时,Go 代码的常见写法是省略 else 部分.无论满足哪个条件都会返回 x 或者 y 时,一般使用以下写法：

1
2
3
4
if condition {
	return x
}
return y

注意事项 不要同时在 if-else 结构的两个分支里都使用 return 语句,这将导致编译报错 function ends without a return statement（您可以认为这是一个编译器的 Bug 或者特性）.（ 译者注：该问题已经在 Go 1.1 中被修复或者说改进 ）

一些有用的例子

1.判断一个字符串是否为空：

  • if str == "" { ... }
  • if len(str) == 0 {...} (个人习惯)

2.判断运行 Go 程序的操作系统类型,这可以通过常量 runtime.GOOS 来判断.

1
2
3
4
5
if runtime.GOOS == "windows"	 {
    .	..
} else { // Unix-like
    .	..
}

这段代码一般被放在 init() 函数中执行.这儿还有一段示例来演示如何根据操作系统来决定输入结束的提示：

1
2
3
4
5
6
7
8
9
var prompt = "Enter a digit, e.g. 3 "+ "or %s to quit."

func init() {
    if runtime.GOOS == "windows" {
        prompt = fmt.Sprintf(prompt, "Ctrl+Z, Enter")		
    } else { //Unix-like
        prompt = fmt.Sprintf(prompt, "Ctrl+D")
    }
}

3.函数 Abs() 用于返回一个整型数字的绝对值:

1
2
3
4
5
6
func Abs(x int) int {
    if x < 0 {
        return -x
    }
    return x	
}

4.isGreater 用于比较两个整型数字的大小:

1
2
3
4
5
6
func isGreater(x, y int) bool {
    if x > y {
        return true	
    }
    return false
}

if-else包含一个初始化语句

例如:

1
2
3
4
val := 10
if val > max {
	// do something
}

也可以这样写

1
2
3
if val := 10; val > max {
	// do something
}

注意:使用简短方式 := 声明的变量的作用域只存在于 if 结构中（在 if 结构的大括号之间,如果使用 if-else 结构则在 else 代码块中变量也会存在)。 如果变量在 if 结构之前就已经存在,那么在 if 结构中,该变量原来的值会被覆盖.最简单的解决方案就是不要在初始化语句中声明变量.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import "fmt"

func main() {
	var first int = 10
	var cond int

  //基础款，声明变量赋予好值，再进行if判断
	if first <= 0 {
		fmt.Printf("first is less than or equal to 0\n")
	} else if first > 0 && first < 5 {
		fmt.Printf("first is between 0 and 5\n")
	} else {
		fmt.Printf("first is 5 or greater\n")
	}
	
	//声明变量，在if判断中，先赋值再判断。这个cond赋予的值会覆盖上面的声明变量。
	if cond = 5; cond > 10 {
		fmt.Printf("cond is greater than 10\n")
	} else {
		fmt.Printf("cond is not greater than 10\n")
	}
	
	fmt.Println(cond) //等于5
	
	//在if判断中，声明变量赋值再判断。
	if cond2 := 5; cond2 > 10 {
		fmt.Printf("cond2 is greater than 10\n")
	} else {
		fmt.Printf("cond2 is not greater than 10\n")
	}
	
	fmt.Println(cond2) //报错，未声明cond2。因为if中声明的变量的作用域只存在于if结构中。
}

输出：

1
2
first is 5 or greater
cond is not greater than 10

展开全文 >>

GO 包package和import

什么是package

package用于对我们的程序进行*分类*,以便易于维护. 每个go文件都属于某个包. 每个Go应用程序必须具有main包。包名称应以小写字母书写. 如果更改并重新编译package,则必须重新编译使用此package的所有代码程序！

Import 别名导入

import mongo "mywebapp/libs/mongodb/db"

Import 省略package名导入

这里的点.符号表示,对包 lib 的调用直接省略包名,您我以后就是一家人,不分彼此,您的东西就像我就的一样,随便用.

1
2
3
4
5
package main
import . "github.com/libragen/felix/lib"
func main() {
	SayHello() //如果没有.忽略包名,那么需要lib.SayHello()。不过这样可能要注意函数名或变量名是否会冲突，个人不推荐
}

Import 执行初始化工作导入

import _ "github.com/libragen/felix/lib"

形象解释:这里说的是我还不准备现在使用您们家的东西,但得提前告诉一声.您先做好准备,先准备好饭菜,等我来就行,也有可能我压根就不来.

具体解释:特殊符号“_” 仅仅会导致 lib 执行初始化工作,如初始化全局变量,调用 init 函数。而正常导入一个包的时候，该包的init和其他函数都会被导入。

package和文件的关系

一个文件夹下只能有一个package.

import后面的其实是GOPATH开始的相对目录路径,包括最后一段.

  • 但由于一个目录下只能有一个package,所以import一个路径就等于是import了这个路径下的包.
  • 注意,这里指的是“直接包含”的go文件. 如果有子目录,那么子目录的父目录是完全两个包.
  • 比如您实现了一个计算器package,名叫calc,位于calc目录下; 但又想给别人一个使用范例,于是在calc下可以建个example子目录（calc/example/）, 这个子目录里有个example.go（calc/example/example.go）. 此时,example.go可以是main包,里面还可以有个main函数.
     
     

一个package的文件不能在多个文件夹下.

  • 如果多个文件夹下有重名的package,它们其实是彼此无关的package.
  • 如果一个go文件需要同时使用不同目录下的同名package,需要在import这些目录时为每个目录指定一个package的别名.

展开全文 >>

GO 数据类型(入门篇必读)

为什么是必读？因为这边会给出这个系列的参考/出处文章地址

https://mojotv.cn/

变量声明语法

1
2
3
4
5
6
7
8
9
10
11
12
var a int //声明一个int类型的变量

var b struct { //声明一个结构体
    Name string
}

var a = 8 //声明变量的同时赋值,编译器自动推导其数据类型

var a int = 8 //声明变量的同时赋值

//声明变量的同时赋值更习惯用":="，但注意全局变量不可以用":="
a := 8

go可使用var关键字声明全局变量,但是:=这种方式是不能用在全局变量中的.:=只能用在函数体内部.

1
2
3
4
5
6
7
var (
    a int
    b bool
    xx,yy,dd string="xx","yy","dd"
    //这里省略变量类型也是可以的.
    zz,aa="zz","aa"        //注意用"="，不能用":="
)

go函数体内的变量是如果被声明了,那么必须使用,不然会报错。注:全局变量声明未使用不会报错

1
2
3
4
//已声明,但如果不想使用可以加上_=varName,表示为已抛弃的变量.
var a=1
//标识为已抛弃的变量.
_=a

变量初始化

Go 语言在声明变量时会默认给变量赋个当前类型的空值/零值

在方法中声明一个临时变量并赋初值

1
2
//推荐,会更新值的格式自动声明变量类型
tmpStr :=""

当一个变量或者新值被创建时, 如果没有为其明确指定初始值,go语言会自动初始化其值为此类型对应的零值。

类型 零值
数值类型 0
布尔类型 false
字符串 “”（空字符串）
slice nil
map nil
指针 nil
函数 nil
接口 nil
信道 nil

展开全文 >>

Hexo博客中插入音乐

成品

具体成功已体现在网络掩码文章底部。

操作

一款html5音乐播放器：Aplayer。把Aplayer加入hexo需要用到hexo-tag-aplayer插件。

切换到hexo目录，运行：

1
npm install --save hexo-tag-aplayer

安装完成后，在需要添加音乐的地方加上：

1
{% aplayer "歌曲名称" "作者" "音乐_url" "封面图片_url" "autoplay" %}

文章链接

网易云外链的处理

网易云提供的外链连接无法成功播放，所以找到一篇解决的文章。

例如：杨钰莹的心雨，网址是：http://music.163.com/#/song?id=317151

很明显，ID是317151

那么，这首歌的真实地址就是：http://music.163.com/song/media/outer/url?id=317151.mp3

文章链接

问题

mac端(win端没有测试过)控制不了音量大小，只能空过电脑或耳机条件。


        

        
      

      
    

    

      
      
	

		
		
	


      

      
        

          展开全文 >>
        

      

      
      

    

  









  
    

  

    
      

        
  
    

      网络掩码
    

  

        
        
  	

        
      

    
    

      
        
ip地址的组成（网络位+主机位）
IP地址采用分层结构；


IP地址是由网络号（net ID）与主机号（host ID）两部分组成的。


根据不同的取值范围，IP地址可以分为五类；IP地址中的前5位用于标识IP地址的类别：


1
2
3
4
5
6
7
8
9
10
11
A类地址的第一位为0；  127 => 0(128)1(64)1(32)1(16) 1(8)1(4)1(2)1(1)
网络位7(8-1)位，主机号24位(32-7-1 = 24)

B类地址的前两位为10； 191 => 1(128)0(64)1(32)1(16) 1(8)1(4)1(2)1(1)
网络位14(8+8-2)位，主机号16位(32-14-2 = 16)

C类地址的前三位为110；223 => 1(128)1(64)0(32)1(16) 1(8)1(4)1(2)1(1)
网络位21(8+8+8-3)位，主机号位(32-21-3 = 8)

D类地址的前四位为1110；
E类地址的前五位为11110；


png


实际大多通过子网掩码来区分网络位和主机位，子网掩码跟IP地址一一对应，子网掩码为1的是网络位，为0的是主机位。
如：192.168.1.2 掩码255.255.255.0 。网络位192.168.1 主机位是2


举个例子：比如172.16.2.160/255.255.255.0


这个IP地址的【网络号】就是172.16.2.0 主机号为   0.0.0.160 




划分子网情况




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
如：172.16.2.160/255.255.255.192(IP地址/掩码)

1010   1100   0001   0000   0000   0010   1010   0000   (二进制)

1111   1111   1111   1111   1111   1111   1100   0000  （子网掩码）

------------------------------------------相"与"(理解成相乘）

1010   1100   0001   0000   0000   0010   1000   0000（172.16.2.128这就是子网号）

1010   1100   0001   0000   0000   0010   1000   0001（172.16.2.129是第一个主机）

1010   1100   0001   0000   0000   0010   1011   1110（172.16.2.190最后一个主机）

1010   1100   0001   0000   0000   0010   1011   1111   广播地址  172.16.2.191 

个人的理解:
通过ip二进制和子网掩码二进制"与"可以发现，子网掩码二进制 1 的部分代表"网络位", 0 的部分代表"主机位"，
上面的例子可以看出"主机位"有6位，那么最后一段8位前两位是定的10，所以"第一个主机位"是1000 0001，"最后一个主机位"是1011 1110，因为还要留一个"广播地址"1011 1111。 





子网掩码的作用：




    

  1. 将一类ip地址（也就是只确定的网络号的ip）划分为更加小的子网络(通常得到一个c类ip,如：212.26.220.0最后一组是主机号（最大255），用子网掩码分成更小的网段）
    2. 



1
2
3
4
5
6
7
8
9
因为掩码的值是连续的1，那么子网掩码的值也就是有规律的：
比如
1000 0000 ---> 128
1100 0000 ---> 192
1110 0000 ---> 224
1111 0000 ---> 240
1111 1000 ---> 248
1111 1100 ---> 252
1111 1110 ---> 254



    

  1. 将相邻的网络地址合并成同一逻辑网络
    2. 



1
2
3
4
5
两个C类IP地址215.60.30.0与215.60.31.0与子网掩码255.255.254.0
11010111.00111100.00011110.00000000-->215.60.30.0
11010111.00111100.00011111.00000000-->215.60.31.0
11111111.11111111.11111110.10000000-->255.255.254.0//掩码
11010111.00111100.00011110.00000000-->215.60.30.0//都是该网段



注意：一个错误的理解：子网掩码主要目的是增加了ip数量！！！其实并没有增加！！！（也不能说没有增加，比如相同的ip不同子网掩码，实际公网是不存在相同的ip,如果说是两个局域网这种情况，不知道算不算增加了）


补充：


    

  • 只知道ip地址那么只能知道是属于哪一类ip。或者认为没有子网络，比如c类ip，那么前3组是网络号，后面一组是主机号
    

    • 

  • 只有知道子网掩码和ip，才能知道具体的网段和主机号
    

    • 

  • 相同子网掩码未必是同一网段ip,同一网段的ip必然有相同的子网掩码。
    

    • 





“IP地址/ 数字” 是什么意思？例如 192.168.5.12 / 21




数字是子网掩码位（数），说明子网掩码由21个1组成，即 子网掩码是：


1
11111111 11111111 11111000 00000000  ，也就是255.255.248.0



文章链接


子网掩码(网络掩码)的位数
255.255.255.0  => / 24


1111 1111 1111 1111 1111 1111 0000 0000  = 24（总长32，1算，0不算）


已知IP地址和子网掩码,如何快速计算是否在同一网段(仍待验证)
下面哪些IP位于同一子网中？


    

  • 192.168.78.36/29
    • 

  • 192.168.78.42/29
    • 

  • 192.168.78.41/29
    • 

  • 192.168.78.45/29
    • 

  • 192.168.78.48/29
    • 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
通过上面子网掩码29位，我们可以知道 网络位是29位，主机位3位。所以，判断是否同一网段，看"网络位"是否相同。
因为前面都是相同的，所以看最后一段的数字二进制8位扣除3位"主机位"后是否相同。

36 (2 +4)                      0010 0100   =>  0010 0 (扣除3位主机位)

42  (32 + 8 + 2)             0010 1010    => 0010 1

41  (32 + 8 + 1)              0010 1001    => 0010 1

45  (32 + 8 + 4 +1)         0010 1101    =>  0010 1

48  (32 + 16)                  0011  0000   => 0011  0

可以看出 42 41 45在同一网段

那么快速的方法
主机位3位： 2^3 = 8
36/8 = 4
42/8 = 5
41/8 = 5
45/8 = 5
48/8 = 6



下面哪些IP位于同一子网中？


    

  • 192.168.165.24/255.255.254.0 和 192.168.164.78/255.255.254.0
    • 

  • 192.168.165.24/255.255.255.255 和 192.168.164.78/255.255.255.255
    • 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
第一组计算:
255.255.254.0        2^9  =  256

16524 / 256 = 64.5

16478 / 256  = 64.3

商64，相同

第二组计算:
255.255.255.255  2^8 = 128

16524/128 = 129

16478/128 = 128.7

商129和128，不相同



文章地址-还有其他知识点哦


IP地址、子网掩码、网段、网关的关系
IP地址、子网掩码、网络地址、广播地址、网段、网关的关系,例：






name
终端A
终端B
终端C





IP地址
192.168.1.10
192.168.1.23
192.168.1.40




子网掩码
255.255.255.224
255.255.255.224
255.255.255.224




网络地址
192.168.1.0
192.168.1.0
192.168.1.32




广播地址
192.168.1.31
192.168.1.31
192.168.1.63




网段
192.168.1.0~192.168.1.31
192.168.1.0~192.168.1.31
192.168.1.31~192.168.1.63




网关
192.168.1.1
192.168.1.1
192.168.1.32







总结：




    

  • 网络地址=IP地址&子网掩码
    • 

  • 广播地址=IP地址|（！子网掩码）
    • 

  • 网段：网络地址相同的IP地址属于同一网段，即同一子网。
    • 

  • 网关：同一网段（子网）间终端可直接通信，如终端A和终端B；不在同一网段（子网）的终端不能直接通信，需要通过网关才能通信，如终端A和终端C。
    • 



文章地址


        

            

        

        

      

      
    

    

      
      
	

		
		
	


      

      
        

          展开全文 >>
        

      

      
      

    

  









  
    

  

    
      

        
  
    

      哈希算法
    

  

        
        
  	

        
      

    
    

      
        
为什么开启这一篇呢？因为后面要对gopush进行讲解。


一致性哈希算法(图片网上资源，联系可删，描述均为自己观点)


0~2^32-1 可以理解为一个圆的外环均匀分布为2^32个点 => key




jpg




在圆上分布均匀分布4个节点(node)




jpg




查找方式




jpg




删除节点影响




jpg




添加节点影响




jpg




节点少的影响




jpg




虚拟节点




jpg


哈希函数
定义:记录的存储位置 = f(关键字)


第一代：SHA-1(1993),MD5(1992),CRC(1975),Lookup3(2006)
第二代：MurmurHash(2008)
第三代：CityHash,SpookyHash(2011)


通过key获取comet-node节点
MurmurHash 是一种非加密型哈希函数，适用于一般的哈希检索操作。与其它流行的哈希函数相比，对于规律性较强的key，MurmurHash的随机分布特征表现更良好。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// init consistent hashing circle
func (k *Ketama) initCircle2(node []string) {
	h := NewMurmur3C()
	for _, str := range node {
		for i := 0; i < k.vnode; i++ {
			vnode := fmt.Sprintf("%s#%d", str, i)
			h.Write([]byte(vnode))
			vpos := uint(h.Sum32())
			k.nodes = append(k.nodes, vpos)
			k.nodesMapping[vpos] = str
			h.Reset()
		}
	}

	sort.Sort(UIntSlice(k.nodes))
}






      

      
    

    

      
      
	

		
		
	


      

      
        

          展开全文 >>
        

      

      
      

    

  









  
  
    
  


          

        

      

      
    

    




    


  

    
    
      
      
      
    
      
      
      
    
      
      
      
    
    

    
  

  

    
    	

        

          
          
          
        

        

          
tag:

          
          
        

        
    
          
    
            缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
     npm i hexo-generator-json-content --save

    
            3、在根目录_config.yml里添加配置：

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

    
          
    
          
  • 
            
            
    
              
              
            
    
            
    
              
              
            
    
          
    • 
        

    	

    

    
    	

  		
        
  		
    	

    

    
    	

  	  	
  	  		
很惭愧<br><br>只做了一点微小的工作<br>谢谢大家