Gethin Blog's RSS Feed

.NET 本质论

Mon, 26 Apr 2021 00:00:00 GMT

声明：本文仅用做复习整理知识，大部分内容参考自： https://www.cnblogs.com/edisonchou/p/4787775.html https://zhuanlan.zhihu.com/p/38799766

.NET中所有类型的基类是什么？
值类型和引用类型的区别？
装箱和拆箱的原理？
struct和class的区别，struct适用于哪些场合？
C#中方法的参数传递有哪几种方式？
浅复制和深复制的区别？
.NET中栈和堆的差异？
执行string abc="aaa"+"bbb"+"ccc"共分配了多少内存？
托管堆内存分配
简要说说.NET中GC的运行机制
GC机制中如何判断一个对象仍然在被使用？（如何标记）
GC中代（Generation）是什么，分为几代？（如何移动）
GC有什么问题？
托管与非托管资源是什么？
- 托管资源
- 非托管资源
Dispose和Finalize方法在何时被调用？（非托管资源回收方法）
.NET中的托管堆中是否可能出现内存泄露的现象？

.NET中所有类型的基类是什么？

System.Object

值类型和引用类型的区别？

所有继承自System.ValueType的类型是值类型，而其他类型都是引用类型。常用的值类型包括：结构、枚举、整数型、浮点型、布尔型等等。

赋值时的区别值类型的变量直接将获得一个真实的数据副本，而对引用类型的赋值仅仅是把对象的引用赋给变量，这样就可能导致多个变量引用到一个对象实例上。
内存分配的区别引用类型的对象将会在堆上分配内存，而值类型的对象则会在堆栈上分配内存
继承结构的区别

装箱和拆箱的原理？

装箱：CLR需要做额外的工作把堆栈上的值类型移动到堆上，这个操作就被称为装箱。拆箱：装箱操作的反操作，把堆中的对象复制到堆栈中，并且返回其值。

struct和class的区别，struct适用于哪些场合？

struct（结构）是值类型，而class（类）是引用类型。
struct与class相比，不具备继承的特性
struct不能有无参数的构造方法（class默认就有），也不能为成员变量定义初始值。

C#中方法的参数传递有哪几种方式？

ref关键字：引用传递参数，需要在传递前初始化；（ref 要求参数在传入前被初始化）
out关键字：引用传递参数，需要在返回前初始化；（out 要求参数在方法返回前被初始化）
params关键字：允许方法在定义时不确定参数的数量。

浅复制和深复制的区别？

浅复制：复制一个对象的时候，仅仅复制原始对象中所有的非静态类型成员和所有的引用类型成员的引用。（新对象和原对象将共享所有引用类型成员的实际对象）
深复制：复制一个对象的时候，不仅复制所有非静态类型成员，还要复制所有引用类型成员的实际对象。

.NET中栈和堆的差异？

.NET 中的栈堆栈用来存储值类型的对象和引用类型对象的引用（地址），其分配的是一块连续的地址，堆栈上的地址从高位向低位分配内存。

.NET 中的堆托管堆的分配也是连续的（从低位到高位），但是堆中却存在着暂时不能被分配却已经无用的对象内存块。当一个引用类型对象被初始时，会通过指向堆上可用空间的指针分配一块连续的内存，然后使堆栈上的引用指向堆上刚刚分配的这块内存块。

.NET中的非托管堆非托管的堆需要程序员用指针手动地分配和释放内存，.NET中的GC和内存管理不适用于非托管堆。

执行string abc="aaa"+"bbb"+"ccc"共分配了多少内存？

string是引用类型，其内存分配会遵照引用类型的规范。字符串具有不可变性。

string first = "aaa" + "bbb" + "ccc";
string second = "aaabbbccc";

int num = 1;
string str = "aaa" + num.ToString();
Console.WriteLine(str);

string str = "aaa";
str += "bbb";
str += "ccc";
Console.WriteLine(str)

托管堆内存分配

CLR在进程中分配一块保留地址控件-即托管堆托管堆有分为多个区域-垃圾回收堆（GC Heap）和加载堆（Loader Heap）[High-Frequency Heap、Low-Frequency Heap和Stub Heap] Loader Heap最重要的信息就是元数据相关的信息每个Type在Loader Heap上体现一个Method Table，而Method Table中则记录了存储的元数据信息 Loader Heap不受GC控制。 TypeHandle：类型句柄，指向对应实例的方法表，每个对象创建时都包含该附加成员，并占用4个字节的内存空间。 SyncBlockIndex：用于线程同步，每个对象创建时也包含该附加成员la。它指向一块呗称为Synchronization Block的内存块，用于管理对象同步，同样占用4个字节的内存空间。 NextObjPtr，由托管堆维护的一个指针，用于标识下一个新建对象分配时在托管堆中所处的位置。CLR初始化时，NextObjPtr位于托管堆的及地址

首先，将声明一个引用类型变量aUser：（堆栈4字节） VIPUser aUser;
它仅是一个引用（指针），保存在线程的堆栈上，占用4Byte的内存空间，将用于保存VIPUser对象的有效地址，其执行过程正是上文描述的在线程栈上的分配过程。此时aUser未指向任何有效的实例，因此被自行初始化为null，试图对aUser的任何操作将抛出NullReferenceException异常。

接着，通过new操作执行对象创建：（GC托管堆20字节）aUser = new VIPUser();
如上文所言，该操作对应于执行newobj指令，其执行过程又可细分为以下几步：

1、CLR按照其继承层次进行搜索，计算类型及其所有父类的字段，该搜索将一直递归到System.Object类型，并返回字节总数，以本例而言类型VIPUser需要的字节总数为15Byte，具体计算为：VIPUser类型本身字段isVip（bool型）为1Byte；父类User类型的字段id（Int32型）为4Byte，字段user保存了指向UserInfo型的引用，因此占4Byte，而同时还要为UserInfo分配6Byte字节的内存。

2、实例对象所占的字节总数还要加上对象附加成员所需的字节总数，其中附加成员包括TypeHandle和SyncBlockIndex，共计8字节（在32位CPU平台下）。因此，需要在托管堆上分配的字节总数为23字节，而堆上的内存块总是按照4Byte的倍数进行分配，因此本例中将分配24字节的地址空间。

3、CLR在当前AppDomain对应的托管堆上搜索，找到一个未使用的20字节的连续空间，并为其分配该内存地址。事实上，GC使用了非常高效的算法来满足该请求，NextObjPtr指针只需要向前推进20个字节，并清零原NextObjPtr指针和当前NextObjPtr指针之间的字节，然后返回原NextObjPtr指针地址即可，该地址正是新创建对象的托管堆地址，也就是aUser引用指向的实例地址。而此时的NextObjPtr仍指向下一个新建对象的位置。注意，栈的分配是向低地址扩展，而堆的分配是向高地址扩展。

最后，调用对象构造器，进行对象初始化操作，完成创建过程。该构造过程，又可细分为以下几个环节：
（a）构造VIPUser类型的Type对象，主要包括静态字段、方法表、实现的接口等，并将其分配在上文提到托管堆的Loader Heap上。

（b）初始化aUser的两个附加成员：TypeHandle和SyncBlockIndex。（解析类型）将TypeHandle指针指向Loader Heap上的MethodTable，CLR将根据TypeHandle来定位具体的Type；（实现对象实例同步）将SyncBlockIndex指针指向Synchronization Block的内存块，用于在多线程环境下对实例对象的同步操作。

（c）调用VIPUser的构造器，进行实例字段的初始化。实例初始化时，会首先向上递归执行父类初始化，直到完成System.Object类型的初始化，然后再返回执行子类的初始化，直到执行VIPUser类为止。以本例而言，初始化过程为首先执行System.Object类，再执行User类，最后才是VIPUser类。最终，newobj分配的托管堆的内存地址，被传递给VIPUser的this参数，并将其引用传给栈上声明的aUser。(System.Object->User->VIPUser->封装成aUser->地址丢给线程堆栈)

简要说说.NET中GC的运行机制

GC是垃圾回收（Garbage Collect）的缩写,.NET中的垃圾回收是指清理托管堆上不会再被使用的对象内存，并且移动仍在被使用的对象使它们紧靠托管堆的一边。

标记：找到所有不再被使用的对象：对象A和对象C，并标记为垃圾；
移动：移动仍在被使用的对象：对象B和对象D;

通常情况下，我们不需要手动干预垃圾回收的执行，不过CLR仍然提供了一个手动执行垃圾回收的方法：GC.Collect()。当我们需要在某一批对象不再使用并且及时释放内存的时候可以调用该方法来实现。But，垃圾回收的运行成本较高（涉及到了对象块的移动、遍历找到不再被使用的对象、很多状态变量的设置以及Finalize方法的调用等等），对性能影响也较大，因此我们在编写程序时，应该避免不必要的内存分配，也尽量减少或避免使用GC.Collect()来执行垃圾回收。

GC机制中如何判断一个对象仍然在被使用？（如何标记）

Mark-Compact 标记压缩算法 在.NET中引用类型对象实例通常通过引用来访问，而GC判断堆中的对象是否仍然在被使用的依据也是引用。简单地说：当没有任何引用指向堆中的某个对象实例时，这个对象就被视为不再使用。

在GC执行垃圾回收时，会把引用分为以下两类：

（1）根引用：往往指那些静态字段的引用，或者存活的局部变量的引用；

（2）非根引用：指那些不属于根引用的引用，往往是对象实例中的字段。

垃圾回收时，GC从所有仍在被使用的根引用出发遍历所有的对象实例，那些不能被遍历到的对象将被视为不再被使用而进行回收。

GC中代（Generation）是什么，分为几代？（如何移动）

GC会把所有托管堆内的对象按照其已经不再被使用的可能性分为三类，并且从最有可能不被使用的类别开始扫描，.NET对这样的分类类别有一个称呼：代（Generation）。

第0代，新近分配在堆上的对象，从来没有被垃圾收集过。任何一个新对象，当它第一次被分配在托管堆上时，就是第0代。第1代，经历过一次垃圾回收后，依然保留在堆上的对象。第2代，经历过两次或以上垃圾回收后，依然保留在堆上的对象。如果第2代对象在进行完垃圾回收后空间仍然不够用，则会抛出OutOfMemoryException异常。

并不是每次垃圾回收都会同时回收3个代的所有对象，越小的代拥有着越多被释放的机会。

CLR对于代的基本算法是：每执行N次0代的回收，才会执行一次1代的回收，而每执行N次1代的回收，才会执行一次2代的回收。

根据.NET的垃圾回收机制，0代、1代和2代的初始分配空间分别为256KB、2M和10M。 一个对象实例存活的时间越长，那么它就具有更大的机率去存活更长的时间。

因为一次GC回收之后仍然被使用的对象会被移动到更高的代上，因此我们需要避免保留已经不再被使用的对象引用，将对象的引用置为null是告诉.NET该对象不需要再使用的最直接的方法。

在前面我们提到Finalize方法会大幅影响性能，通过结合对代的理解，我们可以知道：在带有Finalize方法的对象被回收时，该对象会被视为正在被使用从而被留在托管堆中，且至少要等一个GC循环才能被释放（为什么是至少一个？因为这取决于执行Finalize方法的线程的执行速度）。很明显，需要执行Finalize方法的那些对象实例，被真正释放时最乐观的情况下也已经位于1代的位置上了，而如果它们是在1代上才开始释放或者执行Finalize方法的线程运行得慢了一点，那该对象就在第2代上才被释放，相对于0代，这样的对象实例在堆中存留的时间将长很多。

GC有什么问题？

首先，GC并不是能释放所有的资源。它不能自动释放非托管资源。 第二，GC并不是实时性的，这将会造成系统性能上的瓶颈和不确定性。 GC并不是实时性的，这会造成系统性能上的瓶颈和不确定性。所以有了IDisposable接口，IDisposable接口定义了Dispose方法，这个方法用来供程序员显式调用以释放非托管资源。

托管与非托管资源是什么？

托管资源

.NET中的所有类型都是（直接或间接）从System.Object类型派生的。.NET中超过80%的资源都是托管资源。 CTS中的类型被分成两大类——引用类型（reference type，又叫托管类型[managed type]），分配在内存堆上；值类型（value type），分配在堆栈上。

非托管资源

ApplicationContext, Brush, Component, ComponentDesigner, Container, Context, Cursor, FileStream, Font, Icon, Image, Matrix, Object, OdbcDataReader, OleDBDataReader, Pen, Regex, Socket, StreamWriter, Timer, Tooltip, 文件句柄, GDI资源, 数据库连接等等资源。可能在使用的时候很多都没有注意到！

Dispose和Finalize方法在何时被调用？（非托管资源回收方法）

Dispose方法我们会在Dispose方法中实现一些托管对象和非托管对象的释放以及业绩业务逻辑的结束工作等等。 But，即使我们实现了Dispose方法，也不能得到任何有关释放的保证，Dispose方法的调用依赖于类型的使用者，当类型被不恰当地使用，Dispose方法将不会被调用,我们一般会借助using等语法来帮助Dispose方法被正确调用。
Finalize方法 Finalize在GC执行垃圾回收时被调用 ①当每个包含Finalize方法的类型的实例对象被分配时，.NET会在一张特定的表结构中添加一个引用并且指向这个实例对象，暂且称该表为“带析构方法的对象表”； ②当GC执行并且检测到一个不被使用的对象时，需要进一步检查“带析构方法的对象表”来查询该对象类型是否含有Finalize方法，如果没有则将该对象视为垃圾，如果存在则将该对象的引用移动到另外一张表，暂且称其为“待析构的对象表”，并且该对象实例仍然被视为在被使用。 ③CLR将有一个单独的线程负责处理“待析构的对象表”，其执行方法内部就是依次通过调用其中每个对象的Finalize方法，然后删除引用，这时托管堆中的对象实例就被视为不再被使用。 ④下一个GC执行时，将释放已经被调用Finalize方法的那些对象实例。
结合使用Dispose和Finalize方法：标准Dispose模式 Finalize方法由于有CLR保证调用，因此比Dispose方法更加安全（这里的安全是相对的，Dispose需要类型使用者的及时调用），但在性能方面Finalize方法却要差很多。因此，我们在类型设计时一般都会使用标准Dispose模式：Finalize方法作为Dispose方法的后备，只有在使用者没有调用Dispose方法的情况下，Finalize方法才被视为需要执行。这一模式保证了对象能够被高效和安全地释放，已经被广泛使用。

标准dispose模式模板

public class BaseTemplate : IDisposable
    {
        // 标记对象是否已经被释放
        private bool isDisposed = false;
        // Finalize方法
        ~BaseTemplate()
        {
            Dispose(false);
        }
        // 实现IDisposable接口的Dispose方法
        public void Dispose()
        {
            Dispose(true);
            // 告诉GC此对象的Finalize方法不再需要被调用
            GC.SuppressFinalize(this);
        }
        // 虚方法的Dispose方法做实际的析构工作
        protected virtual void Dispose(bool isDisposing)
        {
            // 当对象已经被析构，则不必再继续执行
            if(isDisposed)
            {
                return;
            }

            if(isDisposing)
            {
                // Step1:在这里释放托管资源
            }

            // Step2:在这里释放非托管资源

            // Step3:最后标记对象已被释放
            isDisposed = true;
        }

        public void MethodA()
        {
            if(isDisposed)
            {
                throw new ObjectDisposedException("对象已经释放");
            }

            // Put the logic code of MethodA
        }

        public void MethodB()
        {
            if (isDisposed)
            {
                throw new ObjectDisposedException("对象已经释放");
            }

            // Put the logic code of MethodB
        }
    }

    public sealed class SubTemplate : BaseTemplate
    {
        // 标记子类对象是否已经被释放
        private bool disposed = false;

        protected override void Dispose(bool isDisposing)
        {
            // 验证是否已被释放，确保只被释放一次
            if(disposed)
            {
                return;
            }

            if(isDisposing)
            {
                // Step1:在这里释放托管的并且在这个子类型中申明的资源
            }

            // Step2:在这里释放非托管的并且这个子类型中申明的资源

            // Step3:调用父类的Dispose方法来释放父类中的资源
            base.Dispose(isDisposing);
            // Step4:设置子类的释放标识
            disposed = true;
        }
    }

真正做释放工作的只是受保护的虚方法Dispose，它接收一个bool参数，主要用于区分调用者是类型的使用者还是.NET的GC机制。两者的区别在于通过Finalize方法释放资源时不能再释放或使用对象中的托管资源，这是因为这时的对象已经处于不被使用的状态，很有可能其中的托管资源已经被释放掉了。在Dispose方法中GC.SuppressFinalize(this)告诉GC此对象在被回收时不需要调用Finalize方法，这一句是改善性能的关键，记住实现Dispose方法的本质目的就在于避免所有释放工作在Finalize方法中进行。

.NET中的托管堆中是否可能出现内存泄露的现象？

首先，必须明确一点：即使在拥有垃圾回收机制的.NET托管堆上，仍然是有可能发生内存泄露现象的。其次，什么是内存泄露？内存泄露是指内存空间上产生了不再被实际使用却又不能被分配的内存空间，其意义很广泛，像内存碎片、不彻底的对象释放等都属于内存泄露现象。内存泄露将导致主机的内存随着程序的运行而逐渐减少，无论其表现形式怎样，它的危害是很大的，因此我们需要努力地避免。

大对象的分配

NET中所有的大对象（这里主要是指对象的大小超过指定数值[85000字节]）将分配在托管堆内一个特殊的区域内，暂且将其称为“大对象堆”（这也算是CLR对于GC的一个优化策略）。大对象堆中最重要的一个特点就是：没有代级的概念，所有对象都被视为第2代。在回收大对象堆内的对象时，其他的大对象不会被移动，这是考虑到大规模地移动对象需要耗费过多的资源。这样，在程序过多地分配和释放大对象之后，就会产生很多内存碎片。

随着对象的分配和释放不断进行，在不进行对象移动的大对象堆内，将不可避免地产生小的内存碎片。我们所需要做的就是尽量减少大对象的分配次数，尤其是那些作为局部变量的，将被大规模分配和释放的大对象，典型的例子就是String类型。

不恰当地保存根引用

最简单的一个错误例子就是不恰当地把一个对象申明为公共静态变量，一个公共的静态变量将一直被GC视为一个在使用的根引用。更糟糕的是：当这个对象内部还包含更多的对象引用时，这些对象同样不会被释放。

不正确的Finalize方法

不正确的Finalize方法将导致Finalize方法不能被正确执行。如果系统中所有的Finalize方法不能被正确执行，包含它们的对象也只能驻留在托管堆内不能被释放，这样的情况将会导致严重的后果。 Finalize方法应该只致力于快速而简单地释放非托管资源，并且尽可能快地返回。相反，不正确的Finalize方法则可能包含：

1. 没有保护地写文件日志； 2. 访问数据库； 3. 访问网络； 4. 把当前对象赋给某个存活的引用；

例如，当Finalize方法试图访问文件系统、数据库或者网络时，将会有资源争用和等待的潜在危险。试想一个不断尝试访问离线数据库的Finalize方法，将会在长时间内不会返回，这不仅影响了对象的释放，也使得排在Finalize方法队列中的所有后续对象得不到释放，这个连锁反应将会导致很快地造成内存耗尽。此外，如果在Finalize方法中把对象自身又赋给了另外一个存活的引用，这时对象内的一部分资源已经被释放掉了，而另外一部分还没有，当这样一个对象被激活后，将导致不可预知的后果。

算法

Mon, 08 Mar 2021 00:00:00 GMT

这个篇文章主要是算法学习大纲。
主要参考 https://github.com/youngyangyang04/leetcode-master 的学习路线，标号----均为leetcode题号。

数组
链表
哈希表
字符串
栈和队列
二叉树
回溯算法
贪心算法
动态规划

数组

二分查找

搜索插入位置--35--

双指针

移除元素--27--

滑动窗口

长度最小的子数组--209--

链表

链表的理论

链表的种类

单链表、双链表、循环链表

链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表操作

添加、删除、查询

数组和链表在不同场景下的性能分析

插入删除的时间复杂度是O(1),查询的时间复杂度是O(n)

链表的经典题目

虚拟头节点(哨兵节点)

移除链表元素--203--

链表的基本操作

设计链表--707--

反转链表

反转链表--206--

环形链表

环形链表II--142--

哈希表

哈希表介绍

哈希表是根据关键码的值而直接进行访问的数据结构。
哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素。

哈希函数

通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把value映射为哈希表上的索引数字了。

哈希碰撞

拉链法、线性探测法。

常见的三种哈希结构

数组、set（集合）、map（映射）

数组作为哈希表

有效的字母异位词--242--
赎金信--383--

set作为哈希表

两个数组的交集--349--

map作为哈希表

两数之和--1--
三数之和--15--
四数之和--18--
四数相加II--454--

字符串

什么是字符串

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组

要不要使用库函数

反转字符串--344--

双指针法、反转系列

反转字符串II--541--
剑指Offer 05.替换空格
翻转字符串里的单词--151--

KMP

实现 strStr()--28--
重复的子字符串--459--

栈和队列

栈与队列的理论基础

队列是先进先出，栈是先进后出

栈经典题目

栈在系统中的应用

简化路径--71--

括号匹配问题

有效的括号--20--

字符串去重问题

删除字符串中的所有相邻重复项--1047--

逆波兰表达式问题

逆波兰表达式求值--150--

队列的经典题目

滑动窗口最大值问题

滑动窗口最大值--239--

求前 K 个高频元素

前 K 个高频元素--347--

二叉树

二叉树的遍历方式

前序遍历--144--

中序遍历--145--

后序遍历--94--

层级遍历--102--

二叉树的属性

对称二叉树--101--

二叉树最大深度--104--

二叉树最小深度--111--

完全二叉树的节点个数--222--

平衡二叉树--110--

二叉树的所有路径--157--

左叶子之和--404--

找树左下角的值--513--

路径总和--112--

二叉树的修改与构造

翻转二叉树--226--

从中序与后续遍历序列构造二叉树--106--

最大二叉树--654--

合并二叉树--617--

求二叉搜索树的属性

二叉搜索树中的搜索--700--

验证二叉搜索树--98--

二叉搜索树的最小绝对差--530--

二叉搜索树中的众数--501--

把二叉搜索树转换为累加树--538--

二叉树公共祖先问题

二叉树的最近公共祖先--236--

二叉搜索树的最近公共祖先--235--

二叉搜索树的修改和构造

二叉搜索树的插入操作--701--

删除二叉搜索树的节点--450--

修剪二叉搜索树--669--

将有序数组转换为二叉搜索树--108--

回溯算法

组合

组合--77--

电话号码的字母组合--17--

组合总和--39--

组合总和2--40--

组合总和3--216--

分割

分割回文串--131--

复原IP地址--93--

子集

子集--78--

子集2--90--

排列

全排列--46--

全排列2--47--

棋盘问题

N皇后--51--

解数独--37--

其他

递增子序列--491--

重新安排行程--332--

贪心算法

理论基础

简单题目

分发饼干--455--

K次取反后最大化的数组和--1005--

柠檬水找零--860--

序列问题

摆动序列--376--

单调递增的数字--738--

股票问题

买卖股票的最佳时机--122--

买卖股票的最佳时机含手续费--714--

两个维度权衡问题

分发糖果--135--

根据身高重建队列--406--

区间问题

跳跃游戏--55--

跳跃游戏2--45--

用最少数量的箭引爆气球--452--

五重叠区间--435--

划分字母区间--763--

合并区间--56--

其他问题

最大子序和--53--

加油站--134--

监控二叉树--968--

动态规划

Written with StackEdit.

个人技术蓝图

Thu, 18 Feb 2021 00:00:00 GMT

计算机基础 [the-basics-of-computer-science]
语言与平台 [language-and-platform]
算法艺术 [algorithmic-art]
软件工程 [software-engineering]
架构艺术 [architecture-art]
云上漫谈 [cloud-native]

计算机基础 [the-basics-of-computer-science]

计算机的组成原理 [principles-of-computer-composition]

操作系统原理 [principle-operating-system]

编译原理 [principle-of-compiling]

数据库系统 [database-system]

计算机网络 [network-of-computer]

TCP

HTTP

语言与平台 [language-and-platform]

C# & .NET 5 [chsarp-and-dotnet5]

.NET 本质论 [dotnet-essentialism]

dotnet-essentialism

C# 基础语法 [csharp-basic-syntax]

C# 高级用法 [professional-csharp]

新一代的 .NET [new-generation-dotnet]

Swift & IOS [swift-ios]

Python [python]

JS,ES,TS & Vue,React (Gatsby) [js-es-ts-vue-react]

前端框架 [front-end]

Gatsby

JavaScript [js]

算法艺术 [algorithmic-art]

数据结构 [data-structure]

常用算法 [algorithm]

重构 [refactoring]

软件工程 [software-engineering]

开发方法 [software-development-methodologies]

software-development-methodologies

系统分析与设计 [system-analysis-and-design]

软件开发的生命周期 [software-development-lifecycle]

架构艺术 [architecture-art]

架构模式 [architecture-pattern]

设计模式 [design-pattern]

常用组件 [common-components]

Redis [redis]

RabbitMQ [rabbitmq]

Elastic Search [elastic-search]

云上漫谈 [cloud-native]

基础架构篇 [cloud-infrastructure]

introduce-microservice-infrastructure-on-cloud
how-to-setup-kubernetes-on-azure

软件架构篇 [cloud-software-architecture]

DEVOPS [devops]

开发方法

Mon, 08 Feb 2021 00:00:00 GMT

Software Development Methodologies

开发方法

开发方法

软件的生命周期

可行性研究与计划->需求分析->概要设计->详细设计->实现->集成测试->确认测试->使用与维护

软件开发模型

瀑布模型
演化模型
螺旋模型
增量模型
构建组装模型

统一过程

UP的9个核心工作流
业务建模，需求，分析设计，实施，测试，部署，配置与变更管理，项目管理，环境
UP的生命周期
目标里程碑，架构里程碑，能力里程碑，发布里程碑
UP的特点
- UP不但给出类迭代的生命周期，还给出了生命周期每一阶段的迭代指南
- 采用不同迭代方式的UP可以演变为演化模型或增量模型
- 迭代特点使得更容易控制软件开发的风险
- UP本身并不属于敏捷
- 实际应用中可以根据具体问题对UP进行剪裁
架构师在UP中的活动
- 同需求人员和项目管理人员密切协作
- 细化软件架构
- 保持整个架构的概念完整性

敏捷方法

极限编程
- XP是一种轻量（敏捷）、高效、低风险、柔性、可预测、科学而且充满乐趣的软件开发方式。
- 在更短的周期内，更早的提供具体、持续的反馈信息
- 迭代的进行计划编制
- 依赖自动测试程序来监控开发进度，并及早捕获缺陷
- 依赖口头交流、测试和源程序进行沟通
- 倡导持续的、演化式的设计
- 依赖与开发团队内部的紧密协作
- 尽可能达到程序员短期利益和项目长期利益的平衡
- 四大价值观
  沟通，简单，反馈，勇气，（尊重）
- 十二个最佳实践
  计划游戏，小型发布，隐喻，简单设计，测试先行，重构，结对编程，集体代码所有制，持续集成，每周工作40小时，现场客户，编码标准
特性驱动开发
FDD也是一个迭代开发模型，FDD每一步都强调质量，不断的交付可运行的软件，并以很小的开发提供精准的项目进度报告和状态信息。
1. FDD角色定义
  项目经理，首席架构设计师，开发经理，主程序员，程序员，领域专家
2. 核心过程
  开发整体对象模型、构造特征列表、计划特征开发、特征设计、特征构建
3. 最佳实践
  领域对象建模、根据特征进行开发、类的个体所有、组成特征小组、审查、定期构造、配置管
Scrum
Scrum是一个用于开发和维护复杂产品的框架，是一个增量的、迭代的开发过程。
1. Scrum 的五个活动
  产品待办事项列表梳理、Sprint计划会议、每日Scrum会议、Sprint评审会议、Sprint回顾会议
2. Scrum的5大价值观
  承诺、专注、开放、尊重、勇气
水晶方法
Crystal 是发展一种提倡“机动性“的方法，包括共有的核心元素，每个都含有独特的角色，过程模式，工作产品和实践。
7大体系特征：经常交付，反思改进，渗透式交流，个人安全，焦点，与专家用户建立方便的联系，配有自动测试、配置管理和经常集成功能的技术环境

软件重用

软件重用
源代码重用，架构重用，应用框架重用，业务建模重用，文档及过程的重用，软构件重用，软件服务重用

基于架构的软件设计

ABSD方法于生命周期
ABSD：分解功能，通过选择架构风格来事先质量和业务需求，软件模版的使用
1. 抽象功能需求，包括变化的需求和通用的需求
2. 用例（实际功能需求）
3. 抽象的质量和业务需求
4. 架构选项
5. 质量场景
6. 约束
基于架构的软件开发模型(ABSDM)
- 架构需求
  需求获取，标识构件（生成类图，对类分组，打包构件），需求评审
- 架构设计
  提出软件架构模型，把已标识的构件映射到软件架构中，分析构件的互相作用，产生软件架构，设计评审
- 架构文档化
  输出：架构需求规格说明，测试架构需求的质量设计说明
- 架构复审
- 架构实现
- 架构演化
  需求变动归类，制定架构演化计划，修改、增加或删除构件，更新构件的互相作用，构件组装与测试，技术评审

PYTHON 技巧

Mon, 01 Feb 2021 00:00:00 GMT

Python Learning Notes

Python Quick Grammar

Python Quick Grammar

1. 变量互换

a=1
b=2
a,b=b,a
a,b

(2, 1)

2. 连续赋值

a=b=c=50
a,b,c

(50, 50, 50)

3. 自动解包

a,b,c=[1,2,3]
a,b,c

(1, 2, 3)

a,*others=[1,2,3,4]
print(a)
print(*others)

1
2 3 4

4. 链式比较

a=10
if(5<a<15):
    print(a)

5. 重复列表

[5,2]*4

[5, 2, 5, 2, 5, 2, 5, 2]

6. 重复字符串

"hello"*3

'hellohellohello'

7. 三目运算

age = 30
slogon = "牛逼" if age == 30 else "niubility"
print(slogon)

牛逼

8. 字典合并

a={"a":1}
b={"b":2}
{**a,**b}

{'a': 1, 'b': 2}

9. 字符串反转

s = "i love python"
s[::-1]

'nohtyp evol i'

10. 列表转字符串

s = ["i", "love", "python"]
" ". join(s)

'i love python'

11. for else 语句

foo=[2,3,4,5]
for i in foo:
    if i == 0:
        break
else:
    print("未发现")

未发现

12. 字典推导式

m = {x: x**2 for x in range(5)}
m

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

13. 用Counter查找列表中出现最多的元素

content = ["a", "b", "c", "a", "d", "c", "a"]
from collections import Counter
c = Counter(content)
c. most_common(1)

[('a', 3)]

14. 默认值字典

from collections import defaultdict
d = defaultdict(list)
d['a']. append(1)
d['a']

[1]

15. 赋值表达式

import re
data = "hello123world"
if match:=re. search("(\d+)", data):
    num = match. group(1)
else:
    num=None
num

'123'

16. isinstance

x=1
b=isinstance(x, (int, float))
b

True

17. 用 http.server 共享文件

#python3 -m http. server

18. zip 函数实现字典键值对互换

lang = {"python":". py", "java":". java"}
dict(zip(lang. values(), lang. keys()))

{'. py': 'python', '. java': 'java'}

19. 查找列表中出现次数最多的数字

test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4, 5]
max(set(test), key=test. count)

20. 使用 slots 节省内存

class MyClass(object):
    def __init__(self, name, identifier):
        self. name = name
        self. identifier = identifier
        self. set_up()
 
print(sys. getsizeof(MyClass))
 
class MyClass(object):
    __slots__ = ['name', 'identifier']
 
    def __init__(self, name, identifier):
        self. name = name
        self. identifier = identifier
        self. set_up()
 
print(sys. getsizeof(MyClass))

1064
896

21. 扩展列表

i = ['a','b','c']
i. extend(['e','f','g'])
i

['a', 'b', 'c', 'e', 'f', 'g']

22. 列表负数索引

a = [ 1, 2, 3]
a[-1]

23. 列表切片

a = [0,1,2,3,4,5,6,7,8,9]
a[3:6] # 第3个到第6个之间的元素
a[:5] # 前5个元素
a[5:] # 后5个元素
a[::] # 所有元素（拷贝列表）
a[::2] # 偶数项
a[1::2] # 奇数项
a[::-1]  # 反转列表

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

24. 二维数组变一维数组

import itertools
a = [[1, 2], [3, 4], [5, 6]]
i = itertools. chain(*a)
list(i)

[1, 2, 3, 4, 5, 6]

25. 有索引的迭代

a = ['Merry', 'Christmas ', 'Day']
for i, x in enumerate(a):
    print ('{}: {}'. format(i, x))

0: Merry
1: Christmas 
2: Day

26. 列表推导式

le = [x*2 for x in range(10)]
le  # 每个数取平方
le = [x for x in range(10) if x%2 == 0]
le  # 获取偶数项

[0, 2, 4, 6, 8]

27. 生成器表达式

ge = (x*2 for x in range(10))
print(ge)
print(next(ge))
print(next(ge))
print(next(ge))

<generator object <genexpr> at 0x000001D693764190>
0
2
4

28. 集合推导式

 nums = {n**2 for n in range(10)}
 nums

{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

29. 判断key是否存在字典中

d = {"1":"a"}
print('1' in d)
print(d['1'])
print(d. get("1"))
print(d. get("2"))

True
a
a
None

30. 装饰器

from functools import wraps
 
def tags(tag_name):
    def tags_decorator(func):
        @wraps(func)
        def func_wrapper(name):
            return "<{0}>{1}</{0}>". format(tag_name, func(name))
        return func_wrapper
    return tags_decorator
 
@tags("p")
def get_text(name):
    """returns some text"""
    return "Hello " + name
 
print(get_text("Python"))

<p>Hello Python</p>

31. 字典子集

def sub_dicts(d, keys):
    return {k:v for k, v in d. items() if k in keys}
sub_dicts({1:"a", 2:"b", 3:"c"}, [1,2])

{1: 'a', 2: 'b'}

32. 反转字典

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
zip(d. values(), d. keys())
z = zip(d. values(), d. keys())
dict(z)

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

33. 具名元组

from collections import namedtuple
Point = namedtuple("Point", "x,y")
p = Point(x=1, y=2)
print(p. x)
print(p[0])
print(p. y)
print(p[1])

34. 设置字典默认值

d = dict()
if 'a' not in d:
    d['a'] = []
d['a']. append(1)
d
d. setdefault('b',[]). append(2)
d

{'a': [1], 'b': [2]}

35. 有序字典

from collections import OrderedDict
m = OrderedDict((str(x), x) for x in range(10))
m. keys() # key 按照插入的顺序排列

odict_keys(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])

36. 列表中最大最小的前n个数

import heapq
a = [51, 95, 14, 65, 86, 35, 85, 32, 8, 98]
heapq. nlargest(5,a)
heapq. nsmallest(5,a)

[8, 14, 32, 35, 51]

37. 打开文件

import os
with open('foo. txt', 'w') as f:
    f. write("hello")
os. remove("foo. txt")

38. 两个列表组合成字典

list_1 = ["One","Two","Three"]
list_2 = [1,2,3]
dictionary = dict(zip(list_1, list_2))
print(dictionary)

{'One': 1, 'Two': 2, 'Three': 3}

39. 去除列表中重复元素

my_list = [1,4,1,8,2,8,4,5]
my_list = list(set(my_list))
print(my_list)

[1, 2, 4, 5, 8]

40. 打印日历

import calendar
print(calendar. month(2021, 1))

    January 2021
Mo Tu We Th Fr Sa Su
             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

41. 匿名函数

add = lambda a,b:a+b
add(1,2)

PYTHON 学习笔记(Intermediate)

Wed, 16 Sep 2020 00:00:00 GMT

Python Learning Notes - Intermediate

4. 序列
5. 字符串和正则表达式

4. 序列

4.1 序列

1 索引

abc=["a","b","c","d","e","f"]
print(abc[1])

2 切片（slicing） sname[start:end:step]

print(abc[1:5])
print(abc[0:5:2])

3 序列相加

bcd=["b","c","d"]
print(abc+bcd)

4 乘法

print(bcd*5)

5 检查元素

print("b"  in bcd)

6 计算序列长度、最大值和最小值

print(len(abc))
print(max(abc))
print(min(abc))

4.2 列表(list)

1 创建和删除

lisa=[1,2,3,4,5,6]
lisb=['a',"b",["a",'''bcd''']]
lise=[]
lisr=list(range(1,10,2))
print(lisa,lisb,lise,lisr)
del lisr
print(lisr)

2 遍历

for i in lisa:
	print(i)
for i,item in  enumerate(lisb):
	print(i,item)

3 添加、修改和删除列表元素

lisa.append(7)
print(lisa)
lisa[5] =  7
print(lisa)
del lisa[5]
print(lisa)

4 统计

c=lisa.count(1)
print(c)
i=lisa.index(1)
print(i)
s=sum(lisa)
print(s)
lisa.sort(reverse=True)
print(lisa)
sort=sorted(lisa)
print(sort)
k=[x for x in lisa if x>3]
print(k)

4.3 元组（tuple）

1 元组的基本操作

t=('a',12,("abc","b"),["ggg",99])
print(t)
t=tuple(range(10,20,2))
print(t)
t=('人生苦短',28,'我用PYTHON',[123,456,789])
print(t[0])
print(t[:3])

2 元组推导式

import random
randomnumber=(random.randint(10,100) for i in range(10))
print(randomnumber)
randomnumber=tuple(randomnumber)
print(randomnumber)

a=(1,2,3)
print(a)
a=(2,3,4)
print(a)
a=a+(5,6)
print(a)

遍历后原生成器对象已经不存在了，如下：

number=(i for i in  range(3))
print(number.__next__())
print(number.__next__())
number=tuple(number)
print(number)

元组和列表区别

列表属于可变序列，它的元素可以随时修改或者删除，而元组属于不可变序列，其中元素不可修改，除非整体替换
列表可以使用append(),extend(),insert(),remove()和pop()等方法实现添加和修改列表元素，而元组则没有这几个方法，因为不能向原则添加和修改元素，同样也不能删除元素
列表可以使用切片访问和修改列表中元素，元素也支持切片，但是它只支持通过切片访问元素中的元素，不支持修改
元组比列表的访问和处理速度快，所以如果只需要对其中元素进行访问，而不进行任何修改，建议使用元组而不使用列表
列表不能座位字典的键，而元组则可以

4.4 字典(dictionary)

字典的特性：

通过键而不是通过索引来读取
字典式任意对象的无序集合
字典是可变的，并且可以任意嵌套
字典中的键必须是唯一
字典中的键必须不可变

5. 字符串和正则表达式

5.1 字串常用操作

# 拼接
a='abc'+'bc'+'CD'+str(123)+'@'
print(a)
# 计算长度
print(len(a))
# 截取字符串【string[start:end:step]】
sub=a[2:7:2]
print(sub)
# 分割字符串【str.splite(sep,maxsplit)】
li=a.split('b')
print(li)
li=a.split('b',1)
print(li)
# 检索字符串count find index startswith endswith
print(a.count('b'))
print(a.find('b'))
print(a.index('b'))
print(a.startswith('abc'))
print(a.endswith('123'))
# 字母大小写
print(a.upper())
print(a.lower())
# 去特殊字符
print(a.strip('@'))

格式化字符串常用格式化字符

s 字符串（采用str() 显示）
r 字符串（采用repr() 显示）
c 单个字符串
o 八进制整数
d 十进制整数
e 指数
x 十六进制整数
f 浮点数
% 字符串%

template=  '{:0>9s}\t name:{:s}\t title:sr.{:s}'
print(template.format('1','hello','wang'))

5.2 正则表达式基础

行定位符 ^tm$
元字符 \w\s\d\b
限定符 ? + * {n} {n,} {n,m}
字符类 abc
排除字符 ^abc
选择字符 |
转义字符 \
分组 ()

5.3 使用re模块实现正则表达式

# re.match(pattern.string,[flags])
# re.search(pattern,string,[flags])
# re.findall(pattern,string,[flags])
# re.sub(pattern,repl.string,count,flags)
# re.split(pattern,string,[maxsplite],[flags])

Third Wedding Anniversary (Museum)

Tue, 07 Jul 2020 00:00:00 GMT

Third Wedding Anniversary (Museum)

Time fly, this is a special day because it is my 3rd wedding anniversary. Last sunday，we went to Shanghai Center Town. Lucky, it is no rain that day. As you know, it is alway rain in Rainy Season in Shanghai.
My wife found a funny place in dazhong dianping (大众点评) app. The place is in 38 floor of Shanghai Center Tower named 宝库匠心馆(3A). Awesome, there are a lot of beautful things. The treasures are very delicate and beautful.

Welcome to Shanghai Center Tower

The treasures as below

Scrum 学习笔记

Mon, 22 Jun 2020 00:00:00 GMT

Scrum Learning Notes

理论与价值观
估算与计划
会议与实战
有效原因与指导原则
- 敏捷计划有效原因
- 敏捷估算和计划的 12 条指导原则

理论与价值观

在有限的时间（TimeBox）里团队一起合作（Work Together），我们彼此信任（Trust）并发挥自我最大的能力和优势（Do The Best），持续不断的交付（CI，CD）可用、有价值（Usable，Valuable）的软件，赢得客户的满意。

敏捷宣言

个体和互动高于流程和工具 （合作，信赖）
工作的软件高于详尽的文档 （产品增量）
客户合作高于合同谈判（同一组织）
响应变化高于遵循计划（公开，透明）

5 个价值观

专注 - 由于我们在一段时间内只能专注于少数几件事情，所以我们可以很好的合作并获得优质的产出，我们能够更快的交付有价值的事项。
公开 - 在团队合作中大家都会表达我们做的如何，以及遇到的障碍。我们发现将担忧说出来是一件好事，因为只有这样才能让这些担忧及时得到解决。
尊重 - 因为我们在一起工作，分享和成功失败，这有助培养并加深互相之间的尊重，并帮助彼此成为值得尊重的人。
承诺 - 由于对自己的命运有更大的掌控，我们会有更坚定的信念去获得成功。
勇气 - 因为我们不是单打独斗，我们能够感受到支持，而且掌握更多资源。这一切赋予我们勇气去迎接更大的挑战。

8 大价值观

诚实，开放，勇气，尊重，专注，信任，授权，合作

12 个原则

我们最重要的目标，是通过及早和持续不断地交付有价值的软件使客户满意。
欣然面对需求变化，即使在开发后期也一样。为了客户的竞争优势，敏捷过程掌控变化。
经常地交付可工作的软件，相隔几星期或一两个月，倾向于采取较短的周期。
业务人员和开发人员必须相互合作，项目中的每一天都不例外。
激发个体的斗志，以他们为核心搭建项目。提供所需的环境和支援，辅以信任，从而达成目标。
不论团队内外，传递信息效果最好效率也最高的方式是面对面的交谈。
可工作的软件是进度的首要度量标准。
敏捷过程倡导可持续开发。责任人、开发人员和用户要能够共同维持其步调稳定延续。(稳定的速度)
坚持不懈地追求技术卓越和良好设计，敏捷能力由此增强。
以简洁为本，它是极力减少不必要工作量的艺术。
最好的架构、需求和设计出自自组织团队。
团队定期地反思如何能提高成效，并依此调整自身的行为表现。

3 个角色

PO
Scurm Master
Team

3 个工件

Product Backlog
Sprint Backlog
Burndown chart

5 个活动

产品待办事项列表梳理
Sprint 计划
每⽇ Scrum 站会
Sprint 评审
Sprint 回顾

估算与计划

计划失败的原因

基于活动而不是基于特性
1. 活动不会提前完成
2. 延误沿着计划表向下传递
3. 活动不是互相独立的
  基于活动的计划分散了我们对特性的专注，而特性才是衡量客户价值的单元。解决策略：使用 FDD 策略。
多任务处理导致更多的延迟 - 每个人都达到 100%负荷，这和让高速公路保持 100%负荷结果相同，谁都无法取得任何进展。解决策略：专注 feature，合理估算
不按优先级开发特性 - 传统计划假设所有任务都会完成，但这样会造成如果无法完成会舍弃一些特性，而这些特性可能会比交付的更有价值。解决策略：明确优先级。
忽视不确定性 - 最明显的效果就是造成 delay。解决策略：迭代。
把估算当作承诺 - 估算只是一个可能性，而对一个可能性做出承诺是不可能的。解决策略：对特性承诺而非时间。

估算大小的策略

故事点的优势

故事点有助于驱动跨功能行为
故事点估算不会过期
故事点是纯粹对大小进行度量
故事点估算通常更快
我的理想人天不等于你的理想人天

理想人天

理想人天在团队以外更容易解释
理想人天估算更容易开始
理想人天便于预测速度

使用模糊的故事点产生的不舒服感觉是非常短暂的。
公司让实际人天接近于理想人天的压力会带来负面影响。
使用故事点估算更有说服力。

为价值制定计划

确定优先级因素

价值
1. 估算经济回报是一件很困难的工作，常常需要一种替代方案对价值估算 ** 确定渴望度的优先级
成本
1. 确定经济优先级
新知识
1. 关于产品的知识
2. 关于技术的知识
风险
1. 进度风险
2. 成本风险
3. 功能风险

确定渴望度优先级

客户满意度的 Kano 模型
1. 作为阈值的特性
2. 线性特性
3. 兴奋点和惊喜点
4. Kano 模型
  5 个度量点:
  我希望这样; 我预期就是这样; 我没有意见; 我可以忍受这样; 我不希望这样;

分解用户故事

用户故事的六个特性 - INVEST

独立性 Independent、可协商性 Negotiable、有价值 Valuable、可以估算 Estimable、短小 Small、可测试性 Testable

何时分解用户故事
用户故事太大，不能放进单次迭代的时候
大型故事分解有助于作出更准确的估算
按照数据边界分解
按照用户故事所支持数据的边界来分解大型用户故事
按照操作边界分解
CURD
去除横切考虑
例如：日志
忽略满足性能限制
考虑把功能性和非功能性需求隔离到不同的用户故事，从而分解大型用户故事
分解具有混合优先级的用户故事
如果大型用户故事中的小故事具有不同的优先级，则可以对它们进行分解
不要把故事分解成任务
不要把大型用户分解成任务，而是寻找一种方法来让一颗曳光弹穿过整个故事
避免相关变化的诱惑
避免在具有适当大小的特性中增加相关变化而把事情弄糟，除非这些变化具有相同的优先级
组合用户故事
对于2周一次的迭代周期工作的团队来说，合适的做法是把特性分解成 2-5 天的用户故事
组合小故事

确定经济优先级

收入来源
1. 新收入
2. 增量收入
  促进现有客户购买更多许可
  包含了可以独立出售的可选，附加模块
  包含允许提高收费的功能
  促进对咨询服务的使用
3. 留存收入
  如果不开发项目或主题，公司会损失的收入
4. 操作效率
  需要或者在公司成长后需要很长时间的事
  部门之间更好的集成和交流
  减少人员更替
  对新人缩短培训时间
  任何对时间敏感的过程
  综合多个过程
  任何可以提高准确性和减少返工的工作
经济指标 1 金钱的时间价值 2 净现值 NPV 3 内部收益率 4 投资回收期 5 折现回收期

会议与实战

框架 Skeleton

展示现阶段以及中期目标
展示并澄清 Product Backlog
团队估算 PBI
PO 按照期望团队交付的顺序为 PBI 排序
分成小组协作对需求建模，切分以及确定验收条件

备忘录 Cheat Sheet

梳理之前是否与利益相关者一起评估确认远景、目标和 backlog 条目
团队和主要的利益相关者在场
会议由 ScurmMaster 或者 PO 引导
预留 sprint 总时间的 5%-10%梳理 backlog
PO 把远景、目标和整个 backlog 分享给大家
技术风险是否被确认并创建响应的 spike
Product Backlog 是一个有序列表
把所有的反馈、变更、缺陷记录到 Product Backlog
产品 Backlog 包括现景、近景和远景
团队一起对所有的条目估算
排列靠前的条目都有验收条件而且有具体实例
所有不确定的问题被记录下来等待会后继续调研

Sprint Planning

PART I

展示重要的 PBI
澄清 PBI 相关的问题
团队协作梳理新的 PBI
团队按照顺序尝试选择 PBI

PART II

重新调整“完成的定义”
计算团队下个 Sprint 可用时间
团队一起讨论可能的实现方案
团队协作创建任务并估算
根据时间或速率向 PO 做出最终承诺

Spint Review 框架

评估已经完成的 PBI 与承诺的 PBI 和 Sprint 目标
用讲故事的方式演示完成的功能
收集反馈
展示接下来要做的重要 PBI

Sprint Retrospective

安全感 How much will each person participate
发现 Big Picture
分析 Continue; Fix; Stop;
计划 Where dowe want to be? How do we get there from here?
收尾 How to ducument; How to execute;

发布计划策略

确定满意条件，（日期驱动，特性驱动）
估算用户故事，
选择迭代周期长度，（官方建议：2 周迭代，压力分摊，6x2+1）
估算速度，（速度策略）
确定用户故事的优先级，
选择用户故事和发布时间
- 确定最初 1-3 个迭代的具体工作
- 卡片记录

迭代计划策略

速度驱动的迭代计划（客观）
- 调整优先级
- 确定目标速度
- 确定迭代目标
- 选择用户故事
- 把用户故事分解成任务
  只包含此项目增加价值的工作 - 如“回复邮件 1 小时”。
  尽量明确，直到养成习惯 - 如自动化测试培养。
  会议会占据（很多）时间（整体时间：如开会）。
  缺陷- 发现 bug 的迭代中就修复它们。
  处理依赖性 - 如 mock 数据
  难以分解的工作 - 探针策略
- 对任务进行估算
  一部分设计就够了
  任务的适合大小
承诺驱动的迭代计划（主观）
- 要求团队做出承诺(团队主导，承诺特性非任务)“你们可以承诺交付我们已经讨论过的特性么？”
- 对估算值求和 -实际上大多数团队在计划每天 4-6 个小时的工作量时候能够取得成功
- 维护与承诺

估算速度策略

如果你在给出对速度的估算前可以进行一次或多测迭代，

有效原因与指导原则

敏捷计划有效原因

经常重新计划
- 承认不可能建立完美的计划，可以大量减少焦虑，而且可以逐步的消除这种不精确性。
对大小和持续时间的估算时独立的
- 大小和时间时有关系统的，但很多因素也会影响持续时间。故事点来估算大小，接下来估算速度，然后规模和速度估算结合起来就可以得到持续时间
在不同层次制定计划
- 发布计划，迭代计划，每日计划。1.不同的计划是用于不同的目的事实。2.帮助开发团队从不同的角度来看待项目。
基于特性而不是基于任务制定计划
- 团队可以少做一些关于特定任务的预先考量。让团队思考正在开发的特性。
小故事保持工作流畅
每个迭代都要消除未完成的工作
在团队层次跟踪
- 不要准备个人燃尽图**而只绘制团队层次的燃尽图
承认不确定性并为之计划

敏捷估算和计划的 12 条指导原则

让整个团队参与
在不同层次上进行计划
使用不同度量单位，让对大小和持续时间的估算保持独立
用功能或者日期来体现不确定性
经常重新计划
跟踪进度并沟通
承认学习的重要性
计划具有适当大小的特性
确定特性优先级
最好的估算和计划来源于事实
保留一些松弛度
通过前瞻性计划协调多个团队

JUPYTER NOTEBOOK SHORTCUTS

Thu, 04 Jun 2020 00:00:00 GMT

Jupyter Notebook Shortcuts

Command model

Key	Function	作用
Enter	take you into edit mode	转入编辑模式
Shift-Enter	run the current cell, select below	运行本单元，选中下个单元
Ctrl-Enter	run selected cells	运行本单元
Alt-Enter	run the current cell, insert below	运行本单元，在其下插入新单元
Y	change the cell type to Code	单元转入代码状态
M	change the cell type to Markdown	单元转入 markdown 状态
R	change the cell type to Raw	单元转入 raw 状态
1	set level 1 title	设定 1 级标题-仅在 markdown 状态下
2	set level 2 title	设定 2 级标题
3	set level 3 title	设定 3 级标题
4	set level 4 title	设定 4 级标题
5	set level 5 title	设定 5 级标题
6	set level 6 title	设定 6 级标题
Up	select cell above	选中上方单元
K	select cell above	选中上方单元
Down	select cell below	选中下方单元
J	select cell above	选中下方单元
Shift-K	Move selected cells up	连续选择上方单元
Shift-J	Move selected cells down	连续选择下方单元
A	insert cell above	在上方插入新单元
B	insert cell below	在下方插入新单元
X	cut selected cells	剪切选中的单元
C	copy selected cells	复制选中的单元
Shift-V	paste cells above	粘贴到上方单元
V	paste cells below	粘贴到下方单元
Z	undo cell deletion	恢复删除的最后一个单元
D,D	delete selected cells	删除选中的单元
Shift-M	merge cell below	合并选中的单元
Ctrl-S	save and checkpoint	保存当前 NoteBook
S	Save and Checkpoint	保存当前 NoteBook
L	toggle line numbers	开关行号
O	toggle output	转换输出
Shift-O	toggle output scrolling	转换输出滚动
Esc	close pager	关闭页面
Q	close pager	关闭页面
H	show all shortcuts	显示快捷键帮助
Shift-Space	scroll notebook up	向上滚动
Space	scroll notebook down	向下滚动

Edit Mode

Key	Function	作用
Tab	code completion or indent	代码补全或缩进
Shift-Tab	tooltip	提示
Ctrl-]	indent	缩进
Ctrl-[	dedent	解除缩进
Ctrl-A	select all	全选
Ctrl-Z	undo	撤销
Ctrl-Shift-Z	redo	重做
Ctrl-Y	redo	重做
Ctrl-Home	go to cell start	跳到单元开头
Ctrl-Up	go to cell start	跳到单元开头
Ctrl-End	go to cell end	跳到单元末尾
Ctrl-Down	go to cell end	跳到单元末尾
Ctrl-Left	go one word left	跳到左边一个字首
Ctrl-Right	go one word right	跳到右边一个字首
Ctrl-Backspace	delete word before	删除前面一个字
Ctrl-Delete	delete word after	删除后面一个字
Esc	command mode	切换到命令模式
Ctrl-M	command mode	切换到命令模式
Shift-Enter	run cell, select below	运行本单元，选中下一单元
Ctrl-Enter	run cell	运行本单元
Alt-Enter	run cell, insert below	运行本单元，在下面插入一单元
Ctrl-Shift- -	split cell	分割单元
Ctrl-Shift-Subtract	split cell	分割单元
Ctrl-S	Save and Checkpoint	保存当前 NoteBook
Up	move cursor up or previous cell	光标上移或转入上一单元
Down	move cursor down or next cell	光标下移或转入下一单元
Ctrl-/	toggle comment on current or selected lines	注释整行/撤销注释

Written with StackEdit.

PYTHON 学习笔记(Junior)

Tue, 26 May 2020 00:00:00 GMT

Python Learning Notes - Junior

1. python 入门
2. 变量和数据类型
3. 流程控制

1. python 入门

1.1. 注释

单行注释 # 注释内容
多行注释 """注释内容"""
中文编码声明注释 # coding=utf-8

1.2. 代码缩进

采用代码缩进和冒号“：”区分代码之间的层次，python 对代码缩进非常严格，如果不合理缩进会抛出 SyntaxError 异常。

1.3. 代码规范

1.3.1. 编写规范

每个 import 只导入一个模块
不要再行尾添加分号“；”
仅以每行不超过 80 个字符；如果超过，仅以使用小括号“（）”
使用必要的空行可以提高代码可读性
通常情况下，运算符两侧、函数参数之间、逗号“，”两侧建议使用空格进行分隔
应该避免在循环中使用+和+=运算符累加字符串，推荐做法是将每个字符串加入列表，然后再循环结束后使用 join 方法连接列表。
适当的使用一场处理提高程序容错性

1.3.2. 命名规范

模块名尽量短小，并且全部使用小写字母，可以使用下划线分割多个字母如：game_main
包名尽量短小，并且全部使用小写字母，不推荐使用下划线，如：com.cr
类名采用单词首字母大写形式，即 Pascal 风格如：TakeSomething
模块内部的类采用下划线+Pascal 风格的类名组成如：_TakeSomething
函数、类的属性和方法的命名规则同模块类似，也是全部采用小写字母，多个字母间用下划线_进行分割
常量明明时全部采用大写字母，可以使用下划线
使用单下划线_开头的模块变量或者函数是受保护的，在使用 import * from 语句从模块中导入时这些变量或者函数不能导入
使用双下划线__开头的实例变量或者方法时类私有的

1.4. 基本输出

使用 print() 函数输出
使用 input() 函数输入

2. 变量和数据类型

2.1. 保留字

Python 保留字:
and, as, assert, break, class, continue, def, del, elif, else, except, finally, for, form, False, global, if, import, in, is, lambda, nonlocal, not, None, or, pass, raise, return, try, True, while, with, yield

2.2. 标识符

标识符命名规则：数字，字母，下划线，不能使用保留字

2.3. 变量

在 python 中，不需要先声明变量名及其类型，直接赋值即可创建各种类型变量。

2.4. 基本数据类型

2.4.1.数字类型

整数
1. 十进制
2. 八进制 - 必须以 0o/0O 开头
3. 十六进制 - 必须以 0X/0x 开头
4. 二进制
浮点数
复数

2.4.2. 字符串类型

通常使用‘’，“”，‘“’”。单引号双引号必须再一行，三引号可以分布在多行。
转义符：\（续行符）,\n（换行符）,\0（空）,\t（水平制表符）,"（双引号）,'（单引号）,\（一个反斜杠）,\f（换页）,\0dd（八进制数，dd 表示字符）,\xhh（十六进制数，hh 表示字符）
布尔类型
类型转换
int(x) | float(x) | complex(real [,imag]) | str(x) | repr(x) | eval(str) | chr(x) | ord(x) | hex(x) | oct(x)

2.5. 运算符

2.5.1 数字运算符

+,-,*,/,%(余),//(取整除),**(幂)

2.5.2 赋值运算符

=,+=,-=,*=,/=,%=,//=,**=

2.5.3 比较运算符

>,<,==,!=,>=,<=

2.5.4 逻辑运算符

and,or,not

2.5.5 位运算符

&,|,^,~,<<,>>

3. 流程控制

3.1 选择语句

if 表达式:
	语句块

if 表达式:
	语句块
else:
	语句块

if 表达式:
	语句块
elif 表达式:
	语句块
else:
	语句块

if 表达式:
	if 表达式:
		语句块
	else:
		语句块
else:
	语句块

3.2 条件表达式

a=1
b=a if a>0 else -a

3.3 循环语句

while 表达式:
	循环体
for 迭代变量 in 对象:
	循环体

3.4 跳转语句

break,continue

3.5 pass 空语句

pass 不做任何事

海量数据优化笔记

Mon, 27 Apr 2020 00:00:00 GMT

Massive Data Optimization Notes

海量数据优化
百万数据查询优化技巧三十则
常用SQL

海量数据优化

1. 合理使用索引

索引是数据库中重要的数据结构，它的根本目的就是为了提高查询效率。现在大多数的数据库产品都采用 IBM 最先提出的 ISAM 索引结构。索引的使用要恰到好处，其使用原则如下：

在经常进行连接，但是没有指定为外键的列上建立索引，而不经常连接的字段则由优化器自动生成索引。
在频繁进行排序或分组（即进行 group by 或 order by 操作）的列上建立索引。
在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要建立索引。比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就无必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度。
如果待排序的列有多个，可以在这些列上建立复合索引（compound index）。
使用系统工具。如 Informix 数据库有一个 tbcheck 工具，可以在可疑的索引上进行检查。在一些数据库服务器上，索引可能失效或者因为频繁操作而使得读取效率降低，如果一个使用索引的查询不明不白地慢下来，可以试着用 tbcheck 工具检查索引的完整性，必要时进行修复。另外，当数据库表更新大量数据后，删除并重建索引可以提高查询速度。

2. 避免或简化排序

应当简化或避免对大型表进行重复的排序。当能够利用索引自动以适当的次序产生输出时，优化器就避免了排序的步骤。以下是一些影响因素：

索引中不包括一个或几个待排序的列；
group by 或 order by 子句中列的次序与索引的次序不一样；
排序的列来自不同的表。

为了避免不必要的排序，就要正确地增建索引，合理地合并数据库表（尽管有时可能影响表的规范化，但相对于效率的提高是值得的）。如果排序不可避免，那么应当试图简化它，如缩小排序的列的范围等。

3. 消除对大型表行数据的顺序存取

在嵌套查询中，对表的顺序存取对查询效率可能产生致命的影响。比如采用顺序存取策略，一个嵌套 3 层的查询，如果每层都查询 1000 行，那么这个查询就要查询 10 亿行数据。避免这种情况的主要方法就是对连接的列进行索引。
例如，两个表：学生表（学号、姓名、年龄……）和选课表（学号、课程号、成绩）。如果两个表要做连接，就要在“学号”这个连接字段上建立索引。
还可以使用并集来避免顺序存取。尽管在所有的检查列上都有索引，但某些形式的 where 子句强迫优化器使用顺序存取。下面的查询将强迫对 orders 表执行顺序操作：

SELECT * FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008

虽然在 customernum 和 ordernum 上建有索引，但是在上面的语句中优化器还是使用顺序存取路径扫描整个表。因为这个语句要检索的是分离的行的集合，所以应该改为如下语句：

SELECT * FROM orders WHERE customer_num=104 AND order_num>1001
UNION
SELECT * FROM orders WHERE order_num=1008

这样就能利用索引路径处理查询。

4. 避免相关子查询

一个列的标签同时在主查询和 where 子句中的查询中出现，那么很可能当主查询中的列值改变之后，子查询必须重新查询一次。查询嵌套层次越多，效率越低，因此应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的行。

5. 避免困难的正规表达式

MATCHES 和 LIKE 关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗费时间。例如：

SELECT * FROM customer WHERE zipcode LIKE “98_ _ _”

即使在 zipcode 字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如果把语句改为SELECT * FROM customer WHERE zipcode >“98000”，在执行查询时就会利用索引来查询，显然会大大提高速度。
另外，还要避免非开始的子串。例如语句：SELECT * FROM customer WHERE zipcode[2，3] >“80”，在 where 子句中采用了非开始子串，因而这个语句也不会使用索引。

6.使用临时表加速查询

把表的一个子集进行排序并创建临时表，有时能加速查询。有助于避免多重排序操作，而且在其他方面还能简化优化器的工作。例如：

SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
AND rcvblls.balance>0
AND cust.postcode>“98000”
ORDER BY cust.name

如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个临时文件中，并按客户的名字进行排序：

SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
AND rcvblls.balance>0
ORDER BY cust.name
INTO TEMP cust_with_balance

然后以下面的方式在临时表中查询：

SELECT * FROM cust_with_balance WHERE postcode>“98000”

临时表中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘 I/O，所以查询工作量可以得到大幅减少。
注意：临时表创建后不会反映主表的修改。在主表中数据频繁修改的情况下，注意不要丢失数据。

7. 用排序来取代非顺序存取

非顺序磁盘存取是最慢的操作，表现在磁盘存取臂的来回移动。SQL 语句隐藏了这一情况，使得在写应用程序时很容易写出要求存取大量非顺序页的查询。
有些时候，用数据库的排序能力来替代非顺序的存取能改进查询。

百万数据查询优化技巧三十则

对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：
```
select id from t where num is null
```
可以在 num 上设置默认值 0，确保表中 num 列没有 null 值，然后这样查询：
```
select id from t where num=0
```
应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。
应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
```
select id from t where num=10 or num=20
```
可以这样查询：
```
select id from t where num=10
union all
select id from t where num=20
```
in 和 not in 也要慎用，否则会导致全表扫描，如：
```
select id from t where num in(1,2,3)
```
对于连续的数值，能用 between 就不要用 in 了：
```
select id from t where num between 1 and 3
```
下面的查询也将导致全表扫描：
```
select id from t where name like '%abc%
```
若要提高效率，可以考虑全文检索。
如果在 where 子句中使用参数，也会导致全表扫描。因为 SQL 只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描： select id from t where num=@num 可以改为强制查询使用索引： select id from t with(index(索引名)) where num=@num
应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如： select id from t where num/2=100 应改为: select id from t where num=100*2

应尽量避免在 where 子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：

select id from t where substring(name,1,3)='abc'--name以abc开头的id`
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id

应改为

select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。
在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。
不要写一些没有意义的查询，如需要生成一个空表结构： select col1,col2 into #t from t where 1=0 这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样： create table #t(...)

很多时候用 exists 代替 in 是一个好的选择：

select num from a where num in(select num from b)

用下面的语句替换：

select num from a where exists(select 1 from b where num=a.num)

并不是所有索引对查询都有效，SQL 是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL 查询可能不会去利用索引，如一表中有字段 sex，male、female 几乎各一半，那么即使在 sex 上建了索引也对查询效率起不了作用。
索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过 6 个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。
应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。
尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。
尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。
任何地方都不要使用 select * from t，用具体的字段列表代替“*”，不要返回用不到的任何字段。
尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。
避免频繁创建和删除临时表，以减少系统表资源的消耗。
临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。
在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先 create table，然后 insert。
如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。
尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过 1 万行，那么就应该考虑改写。
使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。
与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。
在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONEINPROC 消息。
尽量避免大事务操作，提高系统并发能力。
尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

常用SQL

常用sql如下：

--select string using in procedure
select b.name, a.text from syscomments a left join sysobjects b on b.id=a.id
where b.xtype='P' and a.text like '%abc%'

--select columns name
select b.name as Table1, a.name as Columns1,a.type  from syscolumns a left join sysobjects b on b.id=a.id
where b.xtype='u' and a.name like '%abc%'

--select table name
select name from sysobjects where xtype='u' and name like '%abc%'

--select string using in function
select b.name, a.text from syscomments a left join sysobjects b on b.id=a.id
where b.xtype='fn' and a.text like '%abc%'

--select string using in view
select b.name, a.text from syscomments a left join sysobjects b on b.id=a.id
where b.xtype='V' and a.text like '%abc%'

Written with StackEdit.

Introduce Microservice & Infrastructure on Cloud

Fri, 17 Apr 2020 07:46:49 GMT

This article will introduce Microservice & Infrastructure on Cloud.

Iaas & Paas & Saas
Virtual Machine & Container
Docker & Kubernetes
Most Basic Architecture
Azure Kubernets Service -AKS
Iaas & Paas & Saas
Virtual Machine & Container
Docker & Kubernetes
Most Basic Architecture
Azure Kubernets Service -AKS

Iaas & Paas & Saas

Infrastructure-as-a-service
Platform-as-a-service
Software-as-a-service

https://www.sherweb.com/blog/cloud-server/what-is-azure-paas/

Virtual Machine & Container

Virtual Machine: Traditional development & deployment，such as IIS & tomcat

Container:

Platform independence: Build it once, run it anywhere
Resource efficiency and density
Effective isolation and resource sharing
Speed: Start, create, replicate or destroy containers in seconds
Immense and smooth scaling
Operational simplicity
Improved developer productivity and development pipeline
Language independence

Docker & Kubernetes

Docker is the popular way which implement container. Other way ex. Azure Service Fabric, Amazon Elastic Container Service

Why use k8s:

Container orchestration
Great for multi-cloud adoption
Deploy and update applications at scale for faster time-to-market (Horizontal auto scaling，Rolling updates，Canary deployments)
Laying the foundation for cloud-native apps
Lower infrastructure costs
It can run on-premise or in a hybrid environment.
You can move a Kubernetes cluster from one hosting vendor to another without changing (almost) any of the deployment and management processes.
Zero-downtime deployments, fault tolerance, high availability, scaling, scheduling, and self-healing add significant value in Kubernetes.

Most Basic Architecture

Service Registration
Service Discovery
Monitoring
Traffic Limit
Routing
Load Balance
Timeout/Retry
Circuit Breaking (熔断)
Service Downgrade
Failover

Azure Kubernets Service -AKS

1. The First Stage

Build application as normal way - Introduce Cloud Native Information

Pod, Node, Replication Controller, Service, Namespace, Ingress, Gateway(Nginx)...

2. Use Third Party Components to Improve The System

Helm,
Traefik,
Kubeapps,
Prometheus,
Grafana,

3. Use Service Mesh (Istio) for Micro Service Management

Gateway & Virtual Service
Cert
Kiali & Grafana
Use CI/CD to deploy your apps.
1. Azure DevOps
2. Scaling
3. Intelligent Routing and Canary Releases
  https://docs.microsoft.com/en-us/azure/aks/servicemesh-istio-scenario-routing?pivots=client-operating-system-linux

How to setup kubernetes on Azure

Wed, 18 Mar 2020 05:41:35 GMT

This article try to record the steps for setting AKS and some components in Azure.

Step 1. How to set AKS Cluster in Azure
Step 2 Open the could shell
Step 3 install Prometheus
Step 4 install Grafana
step 5 Access the Kubernetes web dashboard in AKS
setp 6 install traekit
step 7 install kubeapps

Step 1. How to set AKS Cluster in Azure

This step could reference the official documents as below, https://docs.microsoft.com/en-us/azure/aks/kubernetes-walkthrough-portal

Step 2 Open the could shell

)

The link as https://shell.azure.com/

And input the Command as below

az aks get-credentials --resource-group AKSGroup --name AKSCluster

Step 3 install Prometheus

How to create change nampspace :

kuebctl create ns monitoring
kubectl config set-context --current --namespace=monitoring

The install command as below,

helm install stable/prometheus --name kube-prometheus --set rbac.create=true --namespace monitoring

If you met the issue like

Error: namespaces "monitoring" is forbidden: User "system:serviceaccount:kube-system:default" cannot get resource "namespaces" in API group "" in the namespace "monitoring"

Solution: rbac-config.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: tiller
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: tiller
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
  - kind: ServiceAccount
    name: tiller
    namespace: kube-system

kubectl create -f rbac-config.yaml
helm init --service-account tiller --history-max 200

Step 4 install Grafana

helm install stable/grafana --set persistence.enabled=true --set persistence.accessModes={ReadWriteOnce} --set persistence.size=8Gi -n grafana --namespace monitoring

You can mark the service as LoadBalancer,

kubectl edit svc grafana

Get the password,

kubectl get secret --namespace monitoring grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

step 5 Access the Kubernetes web dashboard in AKS

The shell script as below.

az aks browse --resource-group AKSGroup --name AKSCluster

For RBAC-enabled clusters.

kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard

setp 6 install traekit

install htpasswd.

apt-get install apache2-utils

generate password.

htpasswd -nbm admin password1234

install traefik.

helm install stable/traefik --set dashboard.enabled=true,serviceType=LoadBalancer,rbac.enabled=true,dashboard.auth.basic.admin='$apr1$ZywpxeoS$6U80kYPG116slxBceEsVz0',dashboard.domain=traefik.dashboard --name=traefik --namespace=kube-system

helm delete.

helm del --purge traefik

step 7 install kubeapps

1. Install Kubeapps.

kubectl create namespace kubeapps

helm repo add bitnami https://charts.bitnami.com/bitnami

Helm 2 command

helm install --name kubeapps --namespace kubeapps bitnami/kubeapps

Helm 3 command

helm install kubeapps --namespace kubeapps bitnami/kubeapps --set useHelm3=true

2. Create a Kubernetes API token.

Create service account,

kubectl create serviceaccount kubeapps-operator -n kubeapps

Create cluster role binding,

kubectl create clusterrolebinding kubeapps-operator --clusterrole=cluster-admin --serviceaccount=kubeapps:kubeapps-operator

Get the secret,

kubectl get secret -n kubeapps $(kubectl get serviceaccount kubeapps-operator -n kubeapps -o jsonpath='{.secrets[].name}') -o jsonpath='{.data.token}' | base64 --decode && echo

Gatsby基础知识（下）

Tue, 17 Mar 2020 00:00:00 GMT

这篇文章主要是翻译和记录了一些 Gateby 的基础知识，有助于开发者通过这些基础知识进行快速的开发
Refer to the Article: https://mpolinowski.github.io/gatsby-js-knowledgebase

10 添加文件数据(Adding File Data)
11 使用 Markdown(Working with Markdown)
12 添加 Material-UI
13 添加 Elasticsearch

10 添加文件数据(Adding File Data)

使用 Gatsby，您可以使用 GraphQL 直接从文件中查询数据。 Transformer插件将文件节点转换为各种其他类型的数据，例如 gatsby-transformer-json 将将JSON 文件转换为 JSON 数据节点，而 gatsby-transformer-remark 将将markdown 文件转换为 MarkdownRemark 节点，您可以从中查询 Markdown 的的HTML 表示形式。在这里，我们将使用gatsby-source-filesystem从我们的文件系统创建文件节点。

    npm install --save gatsby-source-filesystem

安装后，将插件添加到 gatsby-config.js。您可以具有此插件的多个实例，以从文件系统上的不同位置读取源节点。

以下设置了 Jekyll 模式：具有 Markdown 文件的页面目录和.json，.yaml，.csv 的数据目录：

{
  resolve: `gatsby-source-filesystem`,
  options: {
    name: `pages`,
    path: `${__dirname}/src/pages/`,
  },
},
{
  resolve: `gatsby-source-filesystem`,
  options: {
    name: `data`,
    path: `${__dirname}/src/data/`,
  },
}

现在，您可以打开 GraphiQL 调试器-在大括号中，当你开始键入 allFiles 时，它应提供自动补全功能。只需按 Enter 接受，然后再次按 CTRL + ENTER 填写所有页面 ID 的查询：

{
    allFile {
      edges {
        node {
          id
        }
      }
    }
}

当你删除 ID 并按 CTRL + SPACE 时，将显示一个包含所有可查询选项的下拉菜单：你可以使用 parent，children 和和relativePath 属性来创建，例如 breadcrumb navigation：

现在，我们可以在/src/pages/page-2.js 中添加 GraphQL 查询，以遍历我们的所有页面并显示一些数据：

export const query = graphql`
  query MyFilesQuery {
    allFile {
      edges {
          node {
            relativePath
            prettySize
            extension
            birthTime(fromNow: true)
        }
      }
    }
  }
`

不要忘记将{data}注入页面组件：

const SecondPage = ({data})  =>

现在，我们可以添加一些 JSX 来遍历所有文件，并在<table>中输出信息

<table>
  <thead>
    <tr>
      <th>relativePath</th>
      <th>prettySize</th>
      <th>extension</th>
      <th>birthTime</th>
    </tr>
  </thead>
  <tbody>
    {data.allFile.edges.map(({ node }, index) => (
      <tr key={index}>
        <td>
          {node.relativePath}
        </td>
        <td>
          {node.prettySize}
        </td>
        <td>
          {node.extension}
        </td>
        <td>
          {node.birthTime}
        </td>
      </tr>
    ))}
  </tbody>
</table>

11 使用 Markdown(Working with Markdown)

11.1 添加 Markdown 到 GraphQL

现在，我们可以访问有关我们所有页面的信息。但是如上所述，在最后一段的开头，我们还可以使用 Gatsby Transformer Plugins 来查找文件并将其内容可以通过 GraphQL 查询。这里，我们希望使用 Markdown 文件并对其进行转换，以便能够在我们的网站上显示其内容。为此所需的 Transformer Plugin 是 gatsby-transformer-remark。首先，我们需要安装插件：

    npm install --save gatsby-transformer-remark

在 gatsby-config.js 中添加：

plugins: [
  `gatsby-transformer-remark`,
]

然后在/src/pages/FirstMDpost/index.md 内创建一个 markdown 页面，其中包含一些 FrontMatter（文件开头的元数据，以后可以由 GraphQL 查询）和一些文本：

---
path: '/md-posts'
title: 'My first Post'
date:   '2017-10-05'
author: 'Mike Polinowski'
chapter: 'Index'
---
# This is my first mardown Post!

现在我们为 GraphQL 提供了 Markdown -与以前一样，只需开始输入 allMardownRemark（ENTER 自动完成），然后按 CTRL + ENTER 完成查询： ![gatsby_10](https://raw.githubusercontent.com/mpolinowski/gatsby-wiki/master/gatsby_10.png =577x189) 现在，我们可以查询 FrontMatter 以及添加到页面文件夹中的每个 MD 文件的 MD 转换为 HTML 的内容：

11.2 发布我们的 Markdown 数据模板

这些 Markdown 表示将要被显示的模板，但是现在我们需要创建一个用于此数据的样式模板。让我们先在/src 内添加一个称为templates的文件夹。现在，向其中添加一个名为post.js的文件，该文件将包含每个帖子条目的结构模板。该文件包含我们帖子的 JSX markup：

import React from 'react'
export default function Template({data}) {
  const {markdownRemark: post} = data
  
  return (
    <div>
      <h1>{post.frontmatter.title}</h1>
      <div dangerouslySetInnerHTML={{__html: post.html}} />
    </div>
  )
}
export const postQuery = graphql`
  query BlogPostByPath($path: String!) {
    markdownRemark(frontmatter: { path: { eq: $path} }) {
      html
      frontmatter {
        path
        title
      }
    }
  }
`

<Template />组件接收{data}属性，这些属性由 GraphQL 查询检索。该查询会查找 markdown 中中frontmatter 里面所有 URL 等于$Path 的帖子，所以如果你在浏览器中键入的这个 URL 是/md-posts，那么路径中带有/md-posts 的文件，就会被调用。然后，查询使用 markdownRemark 插件将 post markdown 转换为 HTML，并在{data}中提供其前题的路径和标题，并将其传递到组件，然后渲染。 Gatsby 已经配置为将/src/pages 中的所有页面路由为我们网站的页面。但是现在我们必须注册来自 markdown 文件和 post.js 模板的帖子。为此，我们必须在应用程序的根目录内创建一个名为 gatsby-node.js 的文件。我们将使用createPages Gatsby API从我们的帖子模板创建页面：

const path = require('path');
exports.createPages = ({boundActionCreators, graphql}) => {
  const {createPage} = boundActionCreators;
  // const createPage = boundActionCreators.createPage;
  const postTemplate = path.resolve('src/templates/post.js');
  return graphql(`{
    allMarkdownRemark {
      edges {
        node {
          html
          id
          frontmatter {
            path
            title
          }
        }
      }
    }
  }`)
  .then(res => {
    if(res.errors) {
      return Promise.reject(res.errors);
    }
    res.data.allMarkdownRemark.edges.forEach(({node}) => {
      createPage({
        path: node.frontmatter.path,
        component: postTemplate
      })
    })
  })
}

保存并重新启动您的应用程序，然后在浏览器中打开 http://localhost:8000/md-posts

11.3 带有 Markdown 的嵌套路由

要为./src/pages/FirstMDpost/index.md 文件创建子帖子，我们可以简单地向文件夹中添加更多文件，并在其前题中定义嵌套路由 - e.g. ./src/pages/FirstMDpost/myfirstpost.md:

---
path: '/md-posts/first-post'
title: 'First Blog Post'
date:   '2017-10-05'
author: 'Mike Polinowski'
chapter: 'Markdown Posts'
---
# This is my first markdown Post!

和 ./src/pages/FirstMDpost/mysecondpost.md:

---
path: '/md-posts/second-post'
title: 'Second Blog Post'
date:   '2017-10-05'
author: 'Mike Polinowski'
chapter: 'Markdown Posts'
---
# A dive into Markdown Syntax

它们可以分别通过http://localhost:8000/md-posts/first-post和http://localhost:8000/md-posts/second-post 来访问

11.4 创建 Index 页面

现在，我们可以使用 GraphQL 检索所有 Markdown 页面并将过滤它们。对于此测试，我们将一个表添加到起始页面，显示最后 10 个帖子（到目前为止，我只发表了 3 3个帖子...），我们希望按日期降序排列它们，并且仅显示 chapter: 'Markdown Posts'的页面，并排除我们的 index.md：

const IndexPage = ({data}) => (
  <div>
      <h2>Markdown Index</h2>
      <p>The table below sorts out all Markdown pages that are not inside the "Markdown Posts" chapter - as defined inside their frontmatter. It also applies a filter, to only display the latest 10 posts. Click on here to display &nbsp;
      <Link to="/md-posts/">
          all Markdown pages
      </Link>
      .</p>
      <table>
        <thead>
          <tr>
            <th>Date</th>
            <th>Link</th>
          </tr>
        </thead>
        <tbody>
        {data.allMarkdownRemark.edges.map(post => (
          <tr key={post.node.id}>
            <td>
              {post.node.frontmatter.date}
            </td>
            <td>
              <Link
                to={post.node.frontmatter.path}>
                {post.node.frontmatter.title}
              </Link>
            </td>
          </tr>
        ))}
        </tbody>
      </table>
  </div>
)
export const pageQuery = graphql`
  query IndexQuery {
      allMarkdownRemark(limit: 10
      sort: {fields: [frontmatter___date], order: DESC}
      filter: { frontmatter: { chapter: {eq: "Markdown Posts"} }}
    ) {
      edges {
        node {
          id
          frontmatter {
            path
            title
            date
          }
        }
      }
    }
  }
`

11.5 缓存 Markdown 中的链接

一旦开始在 Markdown 文件中添加链接，您会发现单击它们会重新加载您的应用程序-这不是很好 :( 但请放心，这里的gatsby-plugin-catch-links可以助您一臂之力！它-安装后，将其添加到./gatsby-config.js 中的 Gatsby 插件中，它就可以正常工作：

    npm install --save gatsby-plugin-catch-links

// In your gatsby-config.js
plugins: [
  `gatsby-plugin-catch-links`,
]

12 添加 Material-UI

为了使我们的生活更轻松，我们希望包含来自@ Materials-UI 的即用型 material 设计组件。我们将安装 v.1.0.0 的测试版-它也需要 Roboto Fontface 和和Material-UI 图标：

    npm install material-ui@next --save
    npm install typeface-roboto --save
    npm install material-ui-icons --save

现在，我们可以轻松地将 Material-UI 组件导入我们的应用程序：

import React from 'react'
import { render } from 'react-dom'
import Button from 'material-ui/Button'
import 'typeface-roboto'
function AppWithButton() {
  return (
    <Button>
      Hello World
    </Button>
  );
}
render(<AppWithButton />, document.querySelector('#app'));

13 添加 Elasticsearch

该项目的先决条件之一是，我们需要为我们的 ElasticSearch Index 创建一个闪电般的界面。我们已经为其构建了ES6 Class component。并将其添加到 Gatsby/Material-UI 中非常简单。

首先，添加./src/pages/search/jsx 并修改 ElasticSearch 组件来配合我们的 UI.

import React, { Component } from 'react'
import Link from 'gatsby-link'
import elasticsearch from 'elasticsearch'
import { withStyles } from 'material-ui/styles'
import Grid from 'material-ui/Grid'
import Button from 'material-ui/Button'
import ResultCards from '../components/ResultCards'
const connectionString = 'localhost:9200'
const _index = 'wiki2_de_2017_09_09'
const _type = 'article'
let client = new elasticsearch.Client({
  host: connectionString,
  log: "trace"
})
const rootStyle = {
    flexGrow: 1,
    marginTop: 30,
  }
export class Search extends Component {
  constructor(props) {
    super(props)
      this.state = { results: [] };
      this.handleChange = this.handleChange.bind(this)
    }
    handleChange(event) {
      const search_query = event.target.value;
      client.search({
            index: _index,
            type: _type,
            body: {
                query: {
                        multi_match: {
                                query: search_query,
                                fields: ['title^100', 'tags^100', 'abstract^20', 'description^10', 'chapter^5', 'title2^10', 'description2^10'],
                                fuzziness: 1,
                            },
                    },
            },
        }).then(function(body) {
            this.setState({ results: body.hits.hits });
          }.bind(this),
          function(error) {
            console.trace(error.message);
          }
        );
    }
    render() {
      return (
        <div className="container">
          <input type="text" onChange={this.handleChange} />
          <SearchResults results={this.state.results} />
        </div>
      );
    }
}
const SearchResults = ({results}) => (
  <div className="search_results">
  <br/><hr/>
  <div className={rootStyle}>
    <Grid container spacing={24}>
      {results.map((result , i) =>
        <ResultCards key={i}
                     image={result._source.image}
                     title={result._source.title2}
                     link={result._source.link}
                     abstract={result._source.abstract}/>
      )}
      </Grid>
    </div>
    <br/><br/><Link to="/" style={{ textDecoration: 'none' }}><Button raised color="primary">Go back to the homepage</Button></Link>
  </div>
)
export default Search

<SearchResults />组件将遍历<ResultCards />组件内的 Material UI Card：

import React from 'react'
import Link from 'gatsby-link'
import Card, { CardActions, CardContent, CardMedia } from 'material-ui/Card'
import Button from 'material-ui/Button'
import Typography from 'material-ui/Typography'
import Grid from 'material-ui/Grid'
const ResultCards = ({image, title, abstract, link}) => (
    <Grid item xs={12} sm={6} lg={4}>
      <Card style={{ maxWidth: 345 }}>
        <CardMedia
          style={{ height: 200 }}
          image={image}
          title={abstract}
        />
        <CardContent>
          <Typography type="headline" component="h4" style={{ minHeight: 60, marginBottom: "10px" }}>
            {title}
          </Typography>
          <Typography component="p" style={{ minHeight: 50, marginBottom: "10px" }}>
            {abstract}
          </Typography>
        </CardContent>
        <CardActions>
          <Link to={link} style={{ textDecoration: 'none' }}>
            <Button dense color="primary">
              Read
            </Button>
          </Link>
          <Button dense color="primary">
            Learn More
          </Button>
        </CardActions>
      </Card>
    </Grid>
)
export default ResultCards

组件将添加来自 ElasticSearch JSON Response 的结果，并给我们一个灵活的卡片网格。

Gatsby基础知识（中）

Tue, 10 Mar 2020 00:00:00 GMT

这篇文章主要是翻译和记录了一些 Gateby 的基础知识，有助于开发者通过这些基础知识进行快速的开发
Refer to the Article: https://mpolinowski.github.io/gatsby-js-knowledgebase

06 属性传递(Passing down Props)
07 Gatsby 插件(Gatsby Plugins)
- 7.1 进度动画
- 7.2 离线支持和清单
08 单页面应用(Single-Page-Application)
09 GraphQL

06 属性传递(Passing down Props)

现在，我们可以从父组件传递属性到Counter组件。例：我们可以通过显示的页面来更改我们的Counter 标题。

6.1 更改头部

<Counter header="This is the Index Counter"  />

这个header的属性现在可以用在Counter组件中的render方法。现在我们可以通过调用他的父组件来为Counter组件获取不同的标头了。

render() {
  return <div>
          <h3>{this.props.header}</h3>
          <p>current count: {this.state.count}</p>
          <button onClick={() => this.setState({ count: this.state.count + 1 })}>plus</button>
          <button onClick={() => this.setState({ count: this.state.count - 1 })}>minus</button>
        </div>
}

6.2 更改样式

样式也是如此-如果我们希望标题与父组件的配色方案匹配，我们只需要将颜色属性传递给 Counter 组件：

<Counter header="This is the Index Counter" color="rebeccapurple"  />

并在组件本身中添加必要的内联样式：

render() {
  return <div>
          <h3 style={{color: this.props.color}}>{this.props.header}</h3>
          <p>current count: {this.state.count}</p>
          <button onClick={() => this.setState({ count: this.state.count + 1 })}>plus</button>
          <button onClick={() => this.setState({ count: this.state.count - 1 })}>minus</button>
        </div>
}

6.3 设置默认属性

为了确保localhost:8000/counter URL 仍可以被打开，我们现在必须在Counter 组件内部定义一个默认的属性 - 如果没有父组件传递 props，则标题标记和字体颜色将是未定义的！这可以通过 Prop-Types 完成，我们需要安装：

npm install --save prop-types

现在，我们可以将其导入到/src/pages/counter.js：

import React from "react"
import PropTypes from "prop-types"

并在Counter组件内（在export语句上方）为 header prop 定义一个默认值：

Counter.defaultProps = {
  header: "Default Counter",
  color: "black",
}

07 Gatsby 插件(Gatsby Plugins)

插件是实现 Gatsby API 的的Node.js 软件包。它们使您能够轻松解决常见的网站构建问题，例如设置 Sass，添加 markdown 支持，过程映像等。

7.1 进度动画

在此示例中，我们要使用 NProgress.js 插件将加载动画添加到我们的网站。您使用 npm 安装 NProgress 插件：

    npm install --save gatsby-plugin-nprogress

现在，我们必须告诉 Gatsby 通过编辑（在文件不存在的情况下创建）应用程序根目录内的 gatsby-config.js 文件来使用该插件。在在starter 模板中，我们已经安装了 react-helmet 插件（此插件如下所述：Page Layout）。现在，只需将 gatsby-plugin-nprogress 添加到数组中：

module.exports = {
  siteMetadata: {
    title: `Gatsby Wiki`,
  },
  plugins: [
      `gatsby-plugin-react-helmet`,
    {
  {
        resolve: `gatsby-plugin-nprogress`,
        options: {
          // Setting a color is optional.
          color: `rebeccapurple`,
          // Disable the loading spinner.
          showSpinner: false,
      },
    },
  ],
}

7.2 离线支持和清单

现在，我们想在网站上添加一个 Serviceworker，以帮助我们缓存应用程序的重要部分，从而为我们提供一定程度的脱机支持-正如 Offline Plugin告诉我们的那样，我们还将安装 Manifest Plugin （请确保它是在 Offline Plugin 之前列出！）。

    npm install --save gatsby-plugin-manifest
    npm install --save gatsby-plugin-offline

现在，将它们添加到我们的 Gatsby 配置中：

module.exports = {
  siteMetadata: {
    title: `Gatsby Wiki`,
  },
  plugins: [
      `gatsby-plugin-react-helmet`,
      {
        resolve: `gatsby-plugin-nprogress`,
        options: {
          // Setting a color is optional.
          color: `rebeccapurple`,
          // Disable the loading spinner.
          showSpinner: false,
      },
    },
    {
      resolve: `gatsby-plugin-manifest`,
      options: {
          name: "Gatsby Wiki",
          short_name: "Gatsby Wiki",
          start_url: "/",
          background_color: "white",
          theme_color: "rebeccapurple",
          display: "minimal-ui",
          icons: [
            {
              // Everything in /static will be copied to an equivalent
              // directory in /public during development and build, so
              // assuming your favicons are in /static/favicons,
              // you can reference them here
              src: `/apple-touch-icon.png`,
              sizes: `180x180`,
              type: `image/png`,
            },
          {
  {
              src: `/favicon.ico`,
              sizes: `256x256`,
              type: `image/png`,
            },
          ],
        },
      },
      `gatsby-plugin-offline`,
  ],
}

08 单页面应用(Single-Page-Application)

Gatsby 基于他的布局特性提供了一个创建 Single-Page-Applications (SPA's)的简单方法。你可以在/src/layout 中找到 JSX 和和CSS。我们正在使用的 Gatsby Starter，已经提供了头导航栏，该头导航栏已在 index.js 文件中定义（并带有必需的 CSS）。您可以看到该应用程序已经使用React-Helmet作为 Gatsby 插件。这个可重用的 React 组件将管理您对文档<head>的所有更改。 Helmet采用纯 HTML 标记并输出纯 HTML 标记。该布局定义了<Header />组件，该组件与<Helmet />组件一起在<TemplateWrapper />内部使用。您到目前为止所创建的页面中的所有内容，都将通过{children}标签注入到 Wrapper 中。这样，您可以创建顶部导航栏，页眉，侧面导航和页脚，然后将其显示在所有网站上。

09 GraphQL

我们可以在应用程序的根目录下的 gatsby-config.js 内定义一些全局变量：

module.exports = {
  siteMetadata: {
    title: `Gatsby Wiki`,
    author: `Mike Polinowski`,
    description: `Trying out Gatsby`,
  },
}

该数据将可用于每个页面，并可使用 GraphQL 查询。只需将以下 GraphQL 查询添加到/src/pages/index.js，即可保留这些值：

export const query = graphql`
  query FirstQuery {
    site {
      siteMetadata {
        title
        author
        description
      }
    }
  }
`

然后，我们需要将此{data}注入父组件<IndexPage />：

const IndexPage = ({data}) =>

现在我们可以查询组件内部的这些数据：

<h1>{data.site.siteMetadata.description}</h1>

为什么是 data.site.siteMetadata？Gatsby 的的graphql 调试器在 http://localhost:8000/___graphql上运行，您也可以使用它来测试查询并查看结果。只需打开调试器，然后尝试我们先前的查询：

Gatsby基础知识（上）

Sun, 01 Mar 2020 00:00:00 GMT

这篇文章主要是翻译和记录了一些 Gateby 的基础知识，有助于开发者通过这些基础知识进行快速的开发
Refer to the Article: https://mpolinowski.github.io/gatsby-js-knowledgebase

00 准备操作
01 开始你的 Gatsby 开发环境(Start your Gatsby development environment)
02 添加内容和链接页面(Adding content and Linking Pages)
03 样式化 JSX(Styling your JSX)
04 添加交互式插件(Adding Interactive Components)
05 向你的站点导入组件(Importing Components to your Sites)

00 准备操作

The default Gatsby starter

Github

有关项目结构的概述，请参阅Gatsby documentation - Building with Components

从您的 CLI 运行此安装程序（假设已安装 Gatsby）：

    gatsby new gatsby-wiki

01 开始你的 Gatsby 开发环境(Start your Gatsby development environment)

现在请转到你的站点目录中，并使用 npm 运行你的 Gatsby 开发环境如下：

    cd gatsby-wiki
    npm run development

看，你可以访问你的网站了http://localhost:8000

02 添加内容和链接页面(Adding content and Linking Pages)

/src/pages/index.js 文件包含常规的 JSX-在<div />标记内添加任何 HTML，可以让它显示在您的网站内。（Gatsby 使用的热加载）

import React from "react"
import Link from "gatsby-link"
const IndexPage = () => (
  <div>
    <h1>Hi people</h1>
    <p>Welcome to your new Gatsby site.</p>
    <p>Now go build something great.</p>
    <Link to="/page-2/">Go to page 2</Link>
  </div>
)
export default IndexPage

你可以通过import Link from gatsby-link使用 Link 组件并链接到其他页面

<Link to="/page-2/">Go to page 2</Link>

链接我们的 index.js 页面到同目录的 page-2 页面。/src /pages 文件夹中的每个 js 文件都会自动被 Gatsby 路由！

03 样式化 JSX(Styling your JSX)

你可以在组件中使用内联样式如：

const IndexPage = () => (
  <div style={{ color: "tomato", background: "blue"}}>
    <h1>Hi people</h1>
    <p>Welcome to your new Gatsby site.</p>
    <p>Now go build something great.</p>
    <Link to="/page-2/">Go to page 2</Link>
  </div>
)

一些高级样式，请查看 Gatsby 插件 Glamor 或者 Styled Components. 如何安装这些插件请查看Gatsby Plugins。

04 添加交互式插件(Adding Interactive Components)

React 允许你向页面中添加交互 - 我们想添加一个计数器，在加载时将其状态设置为 0，并且有两个使用 onClick 事件增加或减少计数器状态的按钮。

我们可以添加一个新文件/src/pages/counter.js并链接到index页面<Link to="/counter/">Go to Counter</Link>。

import React from "react"
class Counter extends React.Component {
  constructor() {
    super()
    this.state = { count: 0 }
  }
  render() {
    return (
      <div>
            <h1>Counter</h1>
            <p>current count: {this.state.count}</p>
            <button onClick={() => this.setState({ count: this.state.count + 1 })}>
          plus
        plus</button>
            <button onClick={() => this.setState({ count: this.state.count - 1 })}>
          minus
        minus</button>
          </div>
    )
  }
}
export default Counter

05 向你的站点导入组件(Importing Components to your Sites)

目前为止，我们将 pages 目录中的每个文件都用作单独的站点。但是 React.js 允许我们采用默认组件-在文件底部导出的默认组件-并将其导入另一个页面。例如，我们可以将上面的<Counter />组件添加到索引页面中（而不是仅链接到它）。我们只需要在/src/pages/index.js开头添加import一行:

import React from "react"
import Link from "gatsby-link"
import Counter from "./counter"

并在 index.js 的的JSX 代码内引用 Counter，如下所示：

const IndexPage = () => (
  <div>
    <h1>Hi people</h1>
    <p>Welcome to your new Gatsby site.</p>
    <p>Now go build something great.</p>
    <Link to="/page-2/">Go to Page 2</Link>
    <br />
    <br />
    <Counter />
  </div>
)