一个程序员的数学素养（1）数学基础

数学是统计学，运筹学，数值分析，计算机算法，机器学习，大数据分析等等无数计算机相关学科的必备基础。

  • 高数–>连续，概率论、拓扑、测度论、复变函数等
  • 线代–>离散，高等代数，抽象代数等

一、数学公式

hexo渲染

由于hexo不直接支持lateX，因此需要安装插件，推荐使用hexo-tag-katex，安装方式：

1
$ npm install hexo-tag-katex --save

使用方式：

1
2
3
4
5
{% katex [displayMode] %}

a^{b^{\sqrt{c}}}

{% endkatex %}

katex语法，和lateX有些区别，可参考官方文档『传送门』。

limx→+∞[abcd] {\lim\limits_{x \to +\infty}} \begin{bmatrix} a & b \\ c & d \end{bmatrix}

jupyter使用

1
2
3
4
5
from IPython.display import Latex
Latex(r"$f(x) = 3x + 7$")
Latex(r"$\sum_{i=1}^n a_i=0$")
Latex(r"$ {\lim\limits_{x \to +\infty}} $")
Latex(r"$ \begin{bmatrix} a & b \\ c & d \end{bmatrix} $ ")

二、质数相关

素数和素性测试

素数，是除了1和自己以外没有除数的自然数。

大素数检测，如果需要枚举mod不现实。可使用费马素性检测来解决，它用来判断数字是素数的可能性的大小。

当p为prime number素数时，对于n<p，有n^p mod p =n，被称为费马小定理。

匹配得到确认的次数越多，素数的可能性就越高。但即使满足所有费马素数性检测，也不能确认它是素数，这样的合数被称为卡迈克尔数或绝对费马伪素数。

实例：5是素数

  • 4^5=1024 mode 5=4
  • 3^5=243 mode 5=3
  • 2^5=32 mode 5=2
  • 1^5=1 mode 5=1

欧拉函数

N以内有多少个小于等于N的正整数与N互质呢？

φ(x)=x∏i=1n(1−1pi) \varphi(x)=x\prod_{i=1}^n(1-\dfrac{1}{p_i})

其中p1, p2…pn为x的所有质因数，x是不为0的整数。

欧拉函数是积性函数，若m,n互质， 则φ(mn)=φ(m)φ(n)。

实例：

φ(1)=1。和1互质的数(小于等于1)就是1本身。
φ(12)=φ(2^2 * 3^1)=12 * (1-1/2)* (1-1/3) = 4。

欧拉定理

如果两个正整数a和n互质，则n的欧拉函数 φ(n) 可以让下面的等式成立：

aφ(n)≡1(modn) a^{\varphi(n)} \equiv 1 (mod n)

a的φ(n)次方被n除的余数为1。或者说，a的φ(n)次方减去1，可以被n整除。

比如，3和7互质，而7的欧拉函数φ(7)等于6，所以3的6次方（729）减去1，可以被7整除（728/7=104）

more >>

展开全文 >>

Python数据分析（3）Matplotlib

一、Matplotlib各种图形demo

『matplotlib官网传送门』

『ipynb文档传送门』

1
2
3
4
5
6
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

#把图画在notebook中
%matplotlib inline

线状图

1
2
3
4
5
6
7
8
9
10
11
12
x = [1,2,3]
y = [5,7,4]

x2 = [1,2,3]
y2 = [10,14,12]
plt.plot(x, y, label='First Line')
plt.plot(x2, y2, label='Second Line')
plt.xlabel('Plot Number')
plt.ylabel('Important var')
plt.title('Interesting Graph\nCheck it out')
plt.legend() #生成默认图例
plt.show()

png

条形图

1
2
3
4
5
6
7
8
plt.bar([1,3,5,7,9],[5,2,7,8,2], label="Example one")
plt.bar([2,4,6,8,10],[8,6,2,5,6], label="Example two", color='g')
plt.legend()
plt.xlabel('bar number')
plt.ylabel('bar height')

plt.title('Epic Graph\nAnother Line! Whoa')
plt.show()

png

直方图Histogram

1
2
3
4
5
6
7
8
9
10
11
population_ages = [22,55,62,45,21,22,34,42,42,4,99,102,110,120,121,122,130,111,115,112,80,75,65,54,44,43,42,48]

bins = [0,10,20,30,40,50,60,70,80,90,100,110,120,130]

plt.hist(population_ages, bins, histtype='bar', rwidth=0.8)

plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()

png

散点图

1
2
3
4
5
6
7
8
9
10
x = [1,2,3,4,5,6,7,8]
y = [5,2,4,2,1,4,5,2]

plt.scatter(x,y, label='skitscat', color='k', s=25, marker="o")

plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()

png

堆叠图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
days = [1,2,3,4,5]

sleeping = [7,8,6,11,7]
eating =   [2,3,4,3,2]
working =  [7,8,7,2,2]
playing =  [8,5,7,8,13]

plt.plot([],[],color='m', label='Sleeping', linewidth=5)
plt.plot([],[],color='c', label='Eating', linewidth=5)
plt.plot([],[],color='r', label='Working', linewidth=5)
plt.plot([],[],color='k', label='Playing', linewidth=5)

plt.stackplot(days, sleeping,eating,working,playing, colors=['m','c','r','k'])

plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()

png

饼图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
slices = [7,2,2,13]
activities = ['sleeping','eating','working','playing']
cols = ['c','m','r','b']

plt.pie(slices,
        labels=activities,
        colors=cols,
        startangle=90,
        shadow= True,
        explode=(0,0.1,0,0),
        autopct='%1.1f%%')

plt.title('Interesting Graph\nCheck it out')
plt.show()

png

more >>

展开全文 >>

Python数据分析（2）Pandas

简介

  • Pandas是Python的一个数据分析包，该工具为解决数据分析任务而创建。
  • Pandas纳入大量库和标准数据模型，提供高效的操作数据集所需的工具。
  • Pandas提供大量能使我们快速便捷地处理数据的函数和方法。
  • Pandas是字典形式，基于NumPy创建，让NumPy为中心的应用变得更加简单。
  • 对于金融行业的用户，pandas提供了大量适用于金融数据的高性能时间序列功能和工具。
  • Excel 2007及其以后的版本的最大行数是1048576，最大列数是16384，超过这个规模的数据可使用Pandas

『ipynb文档传送门』

『pandas中文网』

1
2
3
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Series

1
2
s = pd.Series([1,3,5,np.nan,6,8])
s
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

DataFrame

1
2
dates = pd.date_range('20170101', periods=6)
dates
DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04',
               '2017-01-05', '2017-01-06'],
              dtype='datetime64[ns]', freq='D')

1
2
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df
A B C D
2017-01-01 -0.119313 -0.165029 -1.065599 0.224712
2017-01-02 -0.423993 0.705954 -0.349143 -0.208349
2017-01-03 0.259465 0.896735 0.033814 -1.135184
2017-01-04 -1.568006 0.685092 -0.931491 0.323591
2017-01-05 0.050029 1.938641 -0.193642 0.199692
2017-01-06 -0.041061 -0.845943 1.542987 0.354031 
1
df.head(3)
A B C D
2017-01-01 0.197225 -0.666883 0.855806 0.253851
2017-01-02 -0.291572 0.011976 -1.502192 0.051144
2017-01-03 -0.670941 1.815718 0.503071 0.361448 
1
df.tail(3)
A B C D
2017-01-04 0.465035 0.465077 -0.018313 1.338603
2017-01-05 -0.646332 1.261231 0.058086 -1.643476
2017-01-06 0.375105 0.247912 0.998861 -0.114123 
1
2
3
4
5
6
7
df2 = pd.DataFrame({ 'A' : 1.,
                     'B' : pd.Timestamp('20130102'),
                     'C' : pd.Series(1,index=list(range(4)),dtype='float32'), 
                     'D' : np.array([3] * 4,dtype='int32'),
                     'E' : pd.Categorical(["test","train","test","train"]),
                     'F' : 'foo' })
df2
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo 
1
df2.dtypes
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

1
2
# 列的序号名字
df2.columns
Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

1
2
# 行的序号
df2.index
Int64Index([0, 1, 2, 3], dtype='int64')

1
2
# 把每个值进行打印出来
df2.values
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],
      dtype=object)

1
2
# 数字总结
df2.describe()
A C D
count 4.0 4.0 4.0
mean 1.0 1.0 3.0
std 0.0 0.0 0.0
min 1.0 1.0 3.0
25% 1.0 1.0 3.0
50% 1.0 1.0 3.0
75% 1.0 1.0 3.0
max 1.0 1.0 3.0 
1
2
# 翻转数据
df2.T
0 1 2 3
A 1 1 1 1
B 2013-01-02 00:00:00 2013-01-02 00:00:00 2013-01-02 00:00:00 2013-01-02 00:00:00
C 1 1 1 1
D 3 3 3 3
E test train test train
F foo foo foo foo 
1
2
# axis等于1按列进行排序 如ABCDEFG 然后ascending倒叙进行显示
df2.sort_index(axis=1, ascending=False)
F E D C B A
0 foo test 3 1.0 2013-01-02 1.0
1 foo train 3 1.0 2013-01-02 1.0
2 foo test 3 1.0 2013-01-02 1.0
3 foo train 3 1.0 2013-01-02 1.0 
1
2
#axis等于0按行进行排序 如0123 然后ascending倒叙进行显示
df2.sort_index(axis=0, ascending=False)
A B C D E F
3 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
0 1.0 2013-01-02 1.0 3 test foo 
1
2
#按值进行排序
df2.sort_values(by='E')
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
2 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
3 1.0 2013-01-02 1.0 3 train foo
more >>

展开全文 >>

Python数据分析（2）Pandas（ipython版）

简介

  • Pandas是Python的一个数据分析包，该工具为解决数据分析任务而创建。
  • Pandas纳入大量库和标准数据模型，提供高效的操作数据集所需的工具。
  • Pandas提供大量能使我们快速便捷地处理数据的函数和方法。
  • Pandas是字典形式，基于NumPy创建，让NumPy为中心的应用变得更加简单。
  • 对于金融行业的用户，pandas提供了大量适用于金融数据的高性能时间序列功能和工具。
  • Excel 2007及其以后的版本的最大行数是1048576，最大列数是16384，超过这个规模的数据可使用Pandas

『ipynb文档传送门』

1
2
3
>>> import pandas as pd
>>> import numpy as np
>>> import matplotlib.pyplot as plt

Series

1
2
3
4
5
6
7
8
9
>>> s = pd.Series([1,3,5,np.nan,6,8])
>>> s
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

DataFrame

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
>>> dates = pd.date_range('20170101', periods=6)
>>> dates
DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04',
               '2017-01-05', '2017-01-06'],
              dtype='datetime64[ns]', freq='D')

>>> df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
>>> df
                   A         B         C         D
2017-01-01  2.005030  0.733879 -0.091630 -1.182515
2017-01-02 -0.816147  1.093998 -0.214505 -0.895524
2017-01-03  0.525449  0.592618 -0.843517  0.723407
2017-01-04  2.688099 -0.981475 -0.613816 -0.190706
2017-01-05 -1.129791 -0.653375  2.039835  1.488373
2017-01-06 -0.306414 -0.294490 -0.178337 -0.546832

>>> df.head(3)
                   A         B         C         D
2017-01-01  2.005030  0.733879 -0.091630 -1.182515
2017-01-02 -0.816147  1.093998 -0.214505 -0.895524
2017-01-03  0.525449  0.592618 -0.843517  0.723407

>>> df.tail(3)
                   A         B         C         D
2017-01-04  2.688099 -0.981475 -0.613816 -0.190706
2017-01-05 -1.129791 -0.653375  2.039835  1.488373
2017-01-06 -0.306414 -0.294490 -0.178337 -0.546832
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
>>> df2 = pd.DataFrame({ 'A' : 1.,
...                      'B' : pd.Timestamp('20130102'),
...                      'C' : pd.Series(1,index=list(range(4)),dtype='float32'), 
...                      'D' : np.array([3] * 4,dtype='int32'),
...                      'E' : pd.Categorical(["test","train","test","train"]),
...                      'F' : 'foo' }) 

>>> df2
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo

>>> df2.dtypes
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

>>> df2.columns #列的序号名字
Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

>>> df2.index #行的序号
Int64Index([0, 1, 2, 3], dtype='int64')

>>> df2.values #把每个值进行打印出来
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],
      dtype=object)
      
>>> df2.describe() #数字总结
         A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0

>>> df2.T #翻转数据
                     0         ...                             3
A                    1         ...                             1
B  2013-01-02 00:00:00         ...           2013-01-02 00:00:00
C                    1         ...                             1
D                    3         ...                             3
E                 test         ...                         train
F                  foo         ...                           foo

[6 rows x 4 columns]

>>> df2.sort_index(axis=1, ascending=False) #axis等于1按列进行排序 如ABCDEFG 然后ascending倒叙进行显示
     F      E  D    C          B    A
0  foo   test  3  1.0 2013-01-02  1.0
1  foo  train  3  1.0 2013-01-02  1.0
2  foo   test  3  1.0 2013-01-02  1.0
3  foo  train  3  1.0 2013-01-02  1.0

>>> df2.sort_index(axis=0, ascending=False) #axis等于0按行进行排序 如0123 然后ascending倒叙进行显示
     A          B    C  D      E    F
3  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
0  1.0 2013-01-02  1.0  3   test  foo

>>> df2.sort_values(by='E') #按值进行排序
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
2  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
3  1.0 2013-01-02  1.0  3  train  foo
more >>

展开全文 >>

Python数据分析（1）Numpy

Numpy是python科学计算的基础包，它提供以下功能：

  • 快速高效的多维数组对象ndarray
  • 用于对数组执行元素级计算以及直接对数组执行数学运算的函数
  • 用于读写硬盘上基于数组的数据集的工具
  • 线性代数运算、傅里叶变换，以及随机数生成
  • 用于将C、C++、Fortran代码集成到python的工具

『ipynb文档传送门』

一、基础

1
import numpy as np
1
2
3
# python list方法生成数据
list(range(0,10,2))
#[0, 2, 4, 6, 8]
1
2
3
4
# 二维数据访问
var =[[1,2,3],[4,5,6],[7,8,9]]
var[0][0]
#1
1
2
3
4
5
6
# 根据数组创建np对象
a=np.array(var)
a
# array([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])
1
2
3
# np访问
a[0][0],a[0,0]
#(1, 1)
1
2
3
4
# np数组切片
a[:2,:2]
# array([[1, 2],
#        [4, 5]])
1
2
3
4
5
a1=np.arange(15).reshape(3,5)
a1
# array([[ 0,  1,  2,  3,  4],
#        [ 5,  6,  7,  8,  9],
#        [10, 11, 12, 13, 14]])
1
2
3
# 数组的dimentsions，对应matrix的rows和columns
a1.shape
#(3, 5)
1
2
3
# 数组的维度dimensions数量，numpy也叫axes，线性代数中矩阵的秩
a1.ndim
#2
1
2
3
# 元素的type
a1.dtype
#dtype('int64')
1
2
3
# 元素的type名
a1.dtype.name
#'int64'
1
2
3
# 每个元素的字节数
a1.itemsize
#8
1
2
3
# 元素总数
a1.size
#15
1
2
type(a1)
#numpy.ndarray
1
2
3
b1=np.arange(6)
b1
#array([0, 1, 2, 3, 4, 5])
1
2
print(b1)
#[0 1 2 3 4 5]

二、数组创建

1
2
3
4
# array创建，参数为数组
a2=np.array([6,7,8])
a2
#array([6, 7, 8])
1
2
type(a2)
#numpy.ndarray
1
2
a2.dtype
#dtype('int64')
1
2
3
4
b2=np.array([(1.5,2,3),(4,5,6)])
b2
# array([[1.5, 2. , 3. ],
#       [4. , 5. , 6. ]])
1
2
3
# 元素中有float
b2.dtype
#dtype('float64')
1
2
b2.size
#6
1
2
b2.itemsize
#8
1
2
3
4
5
# 创建复数，包括实数和虚数
c2=np.array([[1,2],[3,4]],dtype=complex)
c2
# array([[1.+0.j, 2.+0.j],
#        [3.+0.j, 4.+0.j]])
1
2
3
4
5
6
# 特定方法，参数为shape，一维：2，二维：(3,4)，三维：(2,3,4)
d2=np.zeros((3,4),dtype=np.complex)
d2
# array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
#        [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
#        [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])
more >>

展开全文 >>

SpringCloud（6）配置中心

一、统一管理微服务配置

微服务的配置管理，一般有以下需求

  • 集中管理配置
  • 不同环境，不同配置。
  • 运行期间可动态调整。如动态调整数据源连接池大小或熔断阈值。
  • 配置修改后可自动更新。

Spring Cloud Config为Spring Cloud子项目，提供一套分布式的配置管理方案，『官方文档传送门』

分为服务端Config Server和客户端Config Client，其中Server端连接git或svn，并对外提供配置信息服务。Client端从Server端获取配置信息。当配置变更时，只需要借助git的push操作来触发更新操作。

二、Config Server

git配置文件

首先需要在git上放置一些yml或properties文件，命名规则为：
{application}-{profile}.***。

  • application 用于Client端连接时配置的spring.application.name，用于过滤配置文件。
  • profile 用于Client端连接时配置的spring.cloud.config.profile，用于区分生产测试等不同环境。
  • label 一般都是master，代表分支。

我们配置了3个yml文件如下(也可使用properties文件)：

1、herr.yml

1
2
3
4
server.port: 8082
#远程配置，默认8082

profile: herr-default

2、herr-dev.yml

1
2
3
4
#server.port=8082
#不设置server.port，则以herr.yml的8082为default

profile: herr-dev

3、herr-pro.yml

1
2
3
server.port: 8086

profile: herr-pro

Server端搭建

more >>

展开全文 >>

SpringCloud（5）断路器

一、雪崩效应和断路器

雪崩效应

在微服务架构中通常会有多个服务层调用，基础服务的故障可能会导致级联故障，进而造成整个系统不可用的情况，这种现象被称为服务雪崩效应。服务雪崩效应是一种因“服务提供者”的不可用导致“服务消费者”的不可用,并将不可用逐渐放大的过程。

如果下图所示：A作为服务提供者，B为A的服务消费者，C和D是B的服务消费者。A不可用引起了B的不可用，并将不可用像滚雪球一样放大到C和D时，雪崩效应就形成了。

解决方案：

  • 为网络请求设置超时，避免资源耗尽
  • 使用断路器

断路器

断路器的原理很简单，如同电力过载保护器。正常情况下，断路器关闭，可正常请求服务。

在一段时间内请求失败率达到一定阈值（错误率/每分钟错误次数等），会打开断路器，其以后的多个调用快速失败，不再访问远程服务器，使得应用程序继续执行而不用等待修正错误，或者浪费CPU时间去等到长时间的超时产生。

断路器打开一段时间后，会自动进入半开状态。允许一个请求访问，如调用成功则关闭断路器。否则继续打开。

断路器开关相互转换的逻辑如下图：

Hystrix介绍

『Hystrix』是Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或第三方库，防止级联失败，提升系统可用性和容错性。

通过以下几点实现延迟和容错：

  • 包裹请求，使用HystrixCommand包裹对依赖的调用逻辑，在独立线程中执行。
  • 跳闸机制
  • 资源隔离，为每个依赖都维护了一个小型的线程池，如线程池已满则会立即拒绝。隔离策略分为线程隔离（THREAD）和信号量隔离（SEMAPHORE）。
  • 监控
  • 回退机制，基于Ribbon时可在回退方法增加Throwable参数，而在Feign上可使用注解@FeignClient的fallbackFactory属性。
  • 自我修复

二、Hystrix配置-基于Ribbon

1、pom.xml

1
2
3
4
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2、@EnableCircuitBreaker

使用@EnableCircuitBreaker注解开启断路器功能

more >>

展开全文 >>

SpringCloud（4）API网关

一、API网关

API Gateway是一个服务器，也可以说是进入系统的唯一节点。这跟面向对象设计模式中的Facade模式很像。API Gateway封装内部系统的架构，并且提供API给各个客户端。它还可能有其他功能，如授权、监控、负载均衡、缓存、请求分片和管理、静态响应处理等。下图展示了一个适应当前架构的API Gateway。

如果客户端直接和各个微服务通信，会有如下问题：

  • 客户端会多次请求不同的微服务，增加客户端复杂性
  • 跨域请求
  • 认证复杂
  • 难以重构

二、 项目基础配置

Zuul是Netflix开源的微服务网关，只是API Gateway的一种实现，其他的还有Nginx Plus、Kong等等。SpringCloud对Zuul进行了整合和增强，Zuul的核心是一系列过滤器：

  • 身份认证与安全
  • 审查与监控
  • 动态路由
  • 压力测试
  • 负载分配
  • 静态响应处理
  • 多区域弹性

为实现Zuul网关，需要几个基础的module，请参考上一节实战（3）。配置不变。

  • eureka-server，作为eureka的server服务注册中心
  • service-provider-1，eureka-client端，连接到eureka-server成为服务提供者1。

三、Zuul项目配置

1、pom.xml依赖

1
2
3
4
5
6
7
8
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

2、启动类中，增加注解@EnableZuulProxy激活zuul。

该注解整合了@EnableCircuitBreaker、@EnableDiscoveryClient，是个组合注解。

3、yml配置中，项目的spring.application.name为service-eureka-zuul，端口8040。

more >>

展开全文 >>

SpringCloud（3）服务消费的负载均衡

一、服务提供者和服务消费者

名词 概念
服务提供者 服务的被调用方
服务消费者 服务的调用方

服务提供者

提供接口服务后，并注册到注册中心。

服务消费者

我们创建了注册中心，以及服务的提供者，并成功地将服务提供者注册到了注册中心上。

要想消费服务是很简单的，我们只需要使用RestTemplate即可，或者例如HttpClient之类的http工具也是可以的。

在集群环境下，我们必然是每个服务部署多个实例，那么“服务消费者”消费“服务提供者”时的负载均衡就是关键。

二、负载均衡器

Ribbon

Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。简单地说，Ribbon是一个客户端负载均衡器。

Ribbon工作时分为两步：第一步先选择 Eureka Server, 它优先选择在同一个Zone且负载较少的Server；第二步再根据用户指定的策略，在从Server取到的服务注册列表中选择一个地址。其中Ribbon提供了多种策略，例如轮询、随机、根据响应时间加权等。

Feign

Feign是一个声明式的web service客户端，它使得编写web service客户端更为容易。创建接口，为接口添加注解，即可使用Feign。Feign可以使用Feign注解或者JAX-RS注解，还支持热插拔的编码器和解码器。Spring Cloud为Feign添加了Spring MVC的注解支持，并整合了Ribbon和Eureka来为使用Feign时提供负载均衡。

三、 项目基础配置

为实现ribbon负载均衡，需要几个基础的module

  • eureka-server，作为eureka的server服务注册中心
  • service-provider-1，eureka-client端，连接到eureka-server成为服务提供者1。
  • service-provider-2，eureka-client端，连接到eureka-server成为服务提供者2。和service-provider-1提供相同的接口。

eureka-server

eureka的服务端基本配置，参考实战（2）的内容，端口为8761。

service-provider

有2个，内容一样，提供的端口分别为8001和8002。

more >>

展开全文 >>

SpringCloud（2）服务发现

一、服务发现（注册中心、服务注册）

微服务系列，而它必不可缺少的组件就是服务发现组件。提到的目前市面上组件有eureka,consul,zooKeeper,etcd，那该如何选型？

特性 Consul ZooKeeper etcd eureka
编写语言 go Java go java
客户端支持 http,dns 跨语言弱，Curator组件 http，Etcd3支持grpc http,非java(sidecar)
多数据中心 支持
KV存储 支持 支持 支持
健康检查 服务状态、内存、硬盘等 (弱)长连接，keepalive 连接心跳 可配支持
watch支持 全量/支持长轮询 支持 支持长轮询 支持长轮询, Eureka 2.0(正在开发中)也计划支持
自身监控 metrics metrics metrics
安全 acl /https acl https支持（弱）
一致性算法 raft paxos raft
CAP理论 CA CP(牺牲可用性) CP(牺牲可用性) AP(一致性弱)
spring cloud 已支持 已支持 已支持 已支持

二、Eureka配置

『Eureka』是Netflix开源的服务发现组件。

Eureka通过集群同步、心跳检查、客户端缓存等机制，提高系统的灵活性、可收缩性和可用性。

我们根据第一个项目spring-cloud-trip-config作为基础，增加eureka作为服务注册中心，分为3个module

  • eureka-server，作为eureka的server服务注册中心
  • eureka-config-server，注册为config-server和eureka-client端，连接到eureka-server成为服务提供者。
  • eureka-config-client，作为config-client和eureka-client端，连接到eureka-server成为服务消费者。

eureka服务端搭建（module：eureka-server）

1、pom.xml依赖

1
2
3
4
5
6
7
8
9
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2、application入口类添加注解@EnableEurekaServer

3、application.yml配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
spring:
  security:
    user:
      # 配置登录的账号是user
      name: user
      # 配置登录的密码是pwd
      password: pwd
server:
  # 指定该Eureka实例的端口
  port: 8761
eureka:
  # 用于连接发送心跳包，以及集群互联
  client:
    # 是否要将自己注册到Eureka Server
    registerWithEureka: false
    # 是否从Eureka Server获取注册信息
    fetchRegistry: false
    serviceUrl:
      # 设置与Eureka Server交互的地址，多个地址间用逗号分隔
      defaultZone: http://user:pwd@localhost:8761/eureka/
more >>

展开全文 >>

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