c++基础之字符串、向量和数组 上一次整理完了《c++ primer》的第二章的内容。这次整理本书的第3章内容。这里还是声明一下，我整理的主要是自己不知道的或者需要注意的内容，以我本人的主观意志为准，并不具备普适性。第三章就开始慢慢的接触连续、线性存储的数据结构了。字符串、数组、vector等都是存储在内存的连续空间中，而且都是线性结构。算是c++语言中的基础数据结构了。命名空间与using使用方式如下using namespace::name;其中name表示命名空间的具体名字如标准库都在std 这个命名空间，如果要引用这个命名空间的内容就写作 using namespace::std;另外namespace可以表示作为关键字，也可以作为具体的命名空间，如果作为具体命名空间的话，name此时应该是命名空间中的类或者函数等等成员，例如要引用cin这个函数的话，可以这样写 using std::cin在使用时除了使用命名空间之外也可以直接带上命名空间的名称，例如要使用cout 做输出时可以这么写 std::cout << "hell world" << std::endl;使用using 可以直接引入命名空间，减少代码编写的字符数，但是当引入多个命名空间，而命名空间中又有相同的成员时，容易引发冲突。所以在使用命名空间时有下面几条建议头文件中不要包含using声明尽量做到每个成员单独使用using声明string 对象定义和初始化string对象初始化string对象有如下几种方式:string() : 初始化一个空字符串string(const string&): 使用一个字符串来初始化另一个字符串，新字符串是传入字符串的一个副本string(char*): 使用一个字符数组来初始化字符串string(int, char): 新字符串是由连续几个相同字符组成需要注意的是，在定义的语句中使用赋值操作符相当于调用对应的初始化语句。而在其他位置使用赋值操作符在执行复写操作string str = "hello world"; //此处调用拷贝构造，并没有调用赋值重载函数string 对象的操作string的操作主要有：os << s: 将s的值写入到os流中，返回osis >> s: 从is流中读取字符串，并赋值给s，字符串以空白分分隔，返回isgetline(is, s): 从is中读取一行，赋值给s，返回iss.empty(): 判断字符串是否为空，为空则返回true，否则返回falses.size(): 返回字符串中字符个数， 类型为string::size_type。它是一个无符号类型的值，而且编译器需要保证它能够存放任何string对象的大小。不要使用size()的返回值与int进行混合运算s[n]: 返回第n个字符s+s1: 返回s和s1拼接后的结果s1=s2: 将s2的值赋值给s1，执行深拷贝s1 == s2: 判断两个字符串是否相等s1 != s2:判断两个字符串不等<, <=, >, >=:字符串比较处理string 中的字符string 本身是一个字符的容器，我们可以使用迭代的方式来访问其中的每一个字符。例如// 字符转化为大写 string s = "hello world"; for(auto it = s.begin(); it != s.end(); it++) { *it = toupper(*it); }针对这种需要在循环中迭代访问每个元素的情况，c++针对for语句进行扩展，使其能够像Java等语言那样支持自动迭代每一个元素，这种语句一般被称之为范围for。// 统计可打印字符 string s = "hello world"; int punctt_count = 0; for(auto c : s){ if(ispunct(c)){ ++punct_count; } }上述代码中c 只是s中每一个字符的拷贝，如果想像之前那样修改字符串中的字符，可以在迭代时使用引用类型//字符串转化为大写 s = "hello world"; for(auto& c : s){ c = toupper(c); }所有同时具有连续存储和线性存储两个特点的数据结构都可以使用下标访问其中的元素。字符串中字符是采用线性和连续存储的。所以这里它也可以采用下标运算符// 字符串转化为大写 string s = "hello world"; for(auto index = 0; index < s.size(); ++index) { s[index] = toupper(s[index]); } 在使用下标时需要注意下标是否超过容器中存储的元素个数。由于在编译与链接时不会检查这个，如果超出在运行时将会产生未定义结果。标准库 vector标准库vector 表示对象的集合，里面需要存储相同类型的对象。可以看作是一个动态数组。vector 被定义在头文件 vector中由于vector中存储的是对象，而引用不是对象，所以不存在存储引用的vector定义和初始化除了可以使用与string相同的初始化方法外，新的标准还支持使用初始化列表来初始化vectorvector<string> vec = {"Hello", "World", "Boy", "Next", "Door"};一般来说都是预先定义一个空的vector对象，在需要的时候使用push_back或者push_front添加元素。需要注意的是在使用迭代器的过程中，不要针对容器做删减操作同样的vector可以使用下标来访问元素，但是需要注意下标只能访问已有元素不能使用下标来添加元素，同时使用下标时需要注意范围。访问超过范围的元素，会引起越界的问题迭代器迭代器是一组抽象，是用来统一容器中元素访问方式的抽象。它能保证不管什么类型的容器，只要使用迭代器，就能使用相同的方式方法从头到尾访问到容器中的所有元素。在这里不用过于纠结跌打器究竟是如何实现的，只需要知道如何使用它。另外提一句，我当初在初学的时候一直把c语言的思路带入到c++中，导致我一直认为跌迭代器就是指针或者下标，我试图使用指针和下标的方式来理解，然后发现很多地方搞的很乱，也很模糊。这个概念我是一直等待学习python和Java这种没有指针、完全面向对象的语言之后，才纠正过来。这里我想起《黑客与画家》书中提到的，编程语言的高度会影响我们看待问题高度。从我的经历来看，我慢慢的理解了这句话的意思。所以这也是我当初学习lisp的一个原因。我想看看被作者称之为数学语言，抽象程度目前最高的语言是什么样的，对我以后看问题有什么影响迭代器提供了两种重要的抽象：提供统一的接口来遍历容器中所有元素；另外迭代器提供统一接口，让我们实际操作容器中的元素使用迭代器迭代器的使用如下：迭代器都是使用begin 获取容器中的第一个元素；使用end获取尾元素的下一个元素迭代器自身可以像操作对象的指针一样操作容器中的对象迭代器比较时，比较的是两个迭代器指向的是否是同一个元素,不支持 >、<比较++ 来使迭代器指向容器中下一个位置的对象，--来指向上一个位置的对象如果不想通过迭代器改变容器中元素的值，可以使用const类型的迭代器，即 const_iterator类型的迭代器#+BEGIN_SRC c++ string s = "Hello World"; for(string::const_iterator it = s.begin(); it != s.end(); it++) { cout << *it << endl; } #+END_SRCbegin 和end返回的是普通类型的迭代器，c++ 11中提供了一套新的方法来获取const类型的迭代器，cbegin和 cend迭代器的常见运算迭代器常见运算：iter + n: 迭代器向前可以加上一个整数，类似于指针加上一个整数，表示迭代器向前移动了若干个元素iter - n: 迭代器往前移动了若干个元素，类似于指针减去一个整数iter1 - iter2: 表示两个迭代器之间的间距，类似于指针的减法、<、>=、<=:根据迭代器的位置来判断迭代器的大小，类似于指针的大小比较迭代器与整数运算，如果超过了原先容器中元素的个数，那么最多只会返回容器中最后一个元素的下一个跌打器，也就是返回值为 end函数的返回迭代器相减得到迭代器之间的距离，这个距离指的是右侧的迭代器移动多少个元素后到达左侧迭代器的位置，其类型定义为difference_type使用迭代器来访问元素时，与使用指针访问指向的对象的方式一样，它重载了解引用运算符和箭头运算符。使我们能够像使用指针那样使用迭代器数组数组与vector相似二者都是线性存储二者存储的都是相同类型的元素与vector不同的是：数组大小固定由于大小在初始化就已经确定，所以在性能上优于vector，灵活性上有些不足定义和初始化内置数组在初始化数组的时候需要注意：数组大小的值可以是字面值常量、常量表达式、或者普通常量定义数组时必须指明类型，不允许用auto由初始化值来进行推断const unsigned int cnt = 42; //常量 constexpr unsigned int sz = 42; //常量表达式 int arr[10]; //使用字面常量指定大小 int arr2[cnt]; //使用常量初始化 int arr3[sz]; //使用常量表达式初始化可以在初始化时不指定大小，后续会根据初始化列表中的元素个数自动推导出数组大小同时指定了数组大小和初始化列表，如果指定大小大于初始化列表中的元素个数，那么前面几个元素按照初始化列表中的值进行初始化，后面多余的元素则初始化为默认值如果指定大小小于初始化列表中元素个数，则直接报错const unsigned int sz = 3; int arr1[sz] = {1, 2, 3}; int arr2[sz] = {1}; // 等价与 arr2[sz] = {1, 0, 0} int arr3[] = {1, 2, 3}; int arr4[sz] = {1, 2, 3, 4}; //错误，初始化列表中元素个数不能大于数组中定义的元素个数字符数组可以直接使用字符串常量进行赋值，数组大小等于字符串长度加一我们可以对数组中某个元素进行赋值，但是数组之间不允许直接进行拷贝和赋值和vector中一样，数组中存储的也是对象，所以不存在存储引用的数组。在理解关于数组的复杂声明时，采用的也是从右往左看理解的方式。或者说我们先找到与[] 结合的部分来理解，与[]结合的部分去掉之后就是数组中元素的类型。int * ptrs[10]; int & refs[10]; int (*Parry)[10]; int (&arrRef)[10];上面的例子中：ptrs，首先与[]结合最紧密的是ptrs 去掉这两个部分，剩下的就是int 这部分表示数组中元素类型是int , 也就是这里定义了一个包含10个int指针元素的数组refs, 首先与[]结合最紧密的是ref2,去掉这个部分，剩下的就是int&，这部分表示数组中元素类型是int&，也就是这里定义了一个包含10个指向int数据的引用的数组，由于不存在存储引用的数组，所以这里是错误的Parry，由于有了括号，与[]结合最紧密的就变成了 int，也就是我们先定义了一个包含10个int类型的数组，而Parry本身是一个指针，所以这里定义的其实是一个指向存储了10个int类型数据的数组的指针同样的方式分析，得到arrRef 其实是一个指向存储了10个int类型数据的数组的引用指针和数组在上面的例子中，已经见过了指针和数组的一些定义方式，例如ptrs 是一个存储了指针的数组，这种数组一般称之为指针数组；Parry是一个指向数组的指针，这种指针被称之为数组指针在某些时候使用数组的时候，编译器会直接将它转化为指针，其中在使用数组名时，编译器会自动转化为数组首元素的地址。int ia[] = {1, 2, 3, 4, 5}; auto ia2 = ia; ia2[2] = 10; // 这里ia2是指向ia数组首元素的指针，这里其实是在修改ia第3个元素的值需要注意的是在使用decltype时，该现象不会发生，decltype只会根据表达式推断出类型，而不会具体计算表达式的值，所以它遇到数组名时，根据上下文知道它是一个数组，而不会实际取得数组首元素的地址int ia[] = {1, 2, 3, 4, 5}; decltype(ia) ia2 = {0}; //这里ia2 是一个独立的数组，与ia无关 ia2[2] = 10;指针也可以看作迭代器的一种，进行迭代时终止条件是数组尾元素下一个位置的地址int ai[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int *pbegin = &ai[0]; int *pend = &ai[10]; for(int* it = pbegin; it != pend; it++) { cout << *it << endl; }c++ 11中引入两个函数来获取数组的begin位置和end位置，分别为begin() 与 end()int ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; for(int *p = begin(ai); p != end(ai); p++) { cout << *p << endl; }c 风格的字符串string转化为char 可以使用string.c_str()函数,该函数返回的是const char，以取保无法通过这个指针修改字符串本身的值，另外该函数返回的地址一直有效，如果后续修改了string的值，那么根据字符串的算法，字符串中保存字符的地址可能发生变化，此时再使用原来返回的指针访问新的字符串，可能会出现问题如果执行完c_str函数后，程序想一直访问其返回的数组，最好将该数组重新拷贝一份string s = "hello world"; const char* pszBuf = s.c_str() char* pBuff = new char[s.size() + 1]; memset(pBuff, 0x00, sizeof(char) * s.size() + 1); strcpy(pBuff, pszBuff); //后面可以直接使用pbuf，即使s字符串改变 s = "boy next door"; //do something delete[] pBuf;为了与旧代码兼容，允许使用数组来初始化一个vector容器，只需要指明需要拷贝的首元素地址和尾元素地址int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10}; vector<int> va(begin(arr), end(arr));多维数组多维数组是数组的数组，数组中每一个成员都是一个数组。当一个数组的元素仍是数组时，需要多个维度来表示，一个表示数组本身的大小，一个维度表示元素中数组大小对于二维数组来说，一般把第一个维度称之为行，第二个维度称之为列。int ia[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; //等价于 int ia[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};多维数组的初始化可以用打括号初始化每个维度的数据，也可以省略中间的大括号，这样它会按照顺序初始化但是需要注意int ia[3][4] = { {0}, {1, 2}, {3, 4, 5} }; int ia[3][4] = {0, 1, 2, 3, 4, 5};上述代码中，二者含义完全不一样,上一个表示每个子元素中的数组如何初始化，最终结果为{0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 5, 0}。下面一个是从第一行开始依次初始化所有元素,最终结果为{0, 1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0}可以使用下标访问数组元素，一个维度对应一个下标int ai[3][4] = {0}; cout << ai[2][3] << endl; //如果下标个数和数组维度一样，将得到具体类型的值 cout << ai[2] << endl; //下标数小于数组维度，得到对应子数组的首地址可以使用for循环遍历数组int a[3][4] = {0}; for(auto row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }上述例子中，由于多维数组中存储的是数组元素，所以row默认是数组元素，也就是数组首地址，是指针类型，也就不能使用内层的迭代了我们可以稍微做一些修改int a[3][4] = {0}; for(auto& row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }使用引用声明之后，row就表示指向内层子数组的一个数组的引用，也就是一个子数组本身，针对数组就可以使用范围for了注意：使用for范围遍历时，除了最内层元素，其余的都需要声明为引用类型多维数组的名称也是数组的首地址定义多维数组的指针时，需要明确，多维数组是存储数组的特殊数组int ai[3][4] = {0}; int (*p)[4] = ai; // int *p[4] 表示的是指针数组，数组有4个成员，每个成员都是一个int* 上述代码，ai是一个存储3个数组元素的数组，每个元素又是存储4个整型元素的数组，因此定义它的指针的时候，需要明确，指针类型应该是数组元素的类型，也就是有4个int型元素的数组的指针当然如果嫌麻烦或者不会写，可以使用auto来定义一般来说，书写多维数组的指针是比较麻烦的一件事，可以使用类型别名让它变得简单点，上面的例子可以改写一下//typedef int int_array_4[4]; 二者是完全等价的 using int_array_4 = int[4]; int_array_4 *pArr = ai; for(; pArr != ai + 3; ++pArr) { for(int *p = *pArr; p != *pArr+4; ++p) { cout << *p << " "; } cout << endl; } 数组名代表的是数组的首元素，多维数组又可以看作是一个存储数组的数组。所以这里ai的名称代表的是一个存储了3个元素的数组，每个元素都是存储4个整型数据的数组。pArr 的类型是存储了4个整型元素的数组的指针，所以这里与ai表示的指针的类型相同。这里我们将ai的值赋值给指针。在循环中，外层循环用来找到ai数组中每个子数组的指针。内层循环中，使用pArr解引用得到指针指向的每一个对象，也就是一个存储了4个整型元素的数组。针对这个数组进行循环，依次取出数组中每一个元素。

2021年阅读清单 之前在新年总结中提到，自己读书数量不够，希望扩大这个数量。也提到过，针对读过的每本书，写点读书感悟什么的。这个算是这个想法的实践。一来可以根据这个清单来统计自己今年到底阅读量有多大，二是简单写点什么，防止读了就忘记了。这里我也不打算写多长，也不作为正式的读书笔记。就搞简单点，类似于朋友圈或者豆瓣读书那样，简单写点文字，主要是自己的感悟和书中的主要内容。《自私的基因》这个是源于我高中教科书上推荐的一本书，去年翻到我一个弟弟的生物书的时候突然想起来这本书还没看过，所以就在kindle上买了来读一下书中将基因作为进化的实际单位，而生物本身只是基因的生存机器。生物繁殖只是基因的赋值。本书采用拟人的手法，将基因看作一个个活生生的人，而基因自身只有一个目的，生存和繁殖。基因的本质是自私的，它能想到的仅仅是如何扩大自身在基因库中的数量，从这点出发，本书探讨了我们在平常生物界看到的利他行为几乎都可以采用自私基因理论进行解释，对他人友善仅仅是为了换取日后他人对自己的友善，族群的舍己为人可以看作是为了保留同样基因的大部分复制，而牺牲少部分。亲情也可以解释为含有一半或者四分之一的父辈或者祖父辈基因等等这些。相对于一般的学术著作，它的写作手法更像是科普著作，书中的内容并不复杂，结构安排合理，一环套一环。是一本值得一看的好书《万物简史》看到这本书名，我以为是一本人类的发明史，结果证明我的眼界确实不够，里面的万物真的是世间万物。从宇宙、到太阳系、到地球、到生物。维度从大到小，依次介绍跟这些发现相关的历史。里面涉及到的人名、时间太多。内容我并没有记住多少。看完这本书给我的感觉是，宇宙到生物，存在的时间跨度太长，人类只是微不足道的一环，而当今科技看似繁荣，看似我们已经在逐渐成为上帝，但是我们连我们居住的宇宙环境、地球、甚至是跟我们做邻居的各种生物都没有搞清楚。 现在人类的未知领域仍然很多，仍需要我辈的努力。《许三观卖血记》这本书是我在闲暇之余，用来打发时间而看的。本书中主人公，许三观通过卖血多次使家庭成功摆脱困境，在看似喜剧的结尾下实际展示出了一出悲剧。小说通过许三观这个小人物从成家到老年，向读者展示了中国近半个世纪的历史变迁。书中最感人的是当然是最后一次为了给儿子治病一路卖血到上海，儿子的病险些将他击垮，但是一路上凭借他的意志以及路人的帮助，最终克服难关。随着孩子的长大，他再也不需要卖血了。最后一家人其乐融融吃了炒猪肝和黄酒。故事到此结束《乌合之众》乌合之众被认为是社会心理学中最具影响力的著作。当初冲着它的各种名头来读它的，但是实际读起来的效果可能并没有那么好。书中反复在强调群体的情绪化、极端化以及低智化的特点，并针对此特点进行扩展说明。但是我总觉得本书在论证时逻辑性不强，扩展的也不够深入，其中许多实例似乎是为了论证而论证，并不具有普适性。书中主要的观点总结起来就是：群体是具有共同目的的集合，这个集合不局限于物理意义上的集合。集合起来的群众智力低下、盲目而又极端，充满原始的暴力和血腥，具有各种情绪化的体现。在当今的互联网时代中，在针对一件事进行讨论之时很容易形成群体，这就给我们理解当今互联网中的各种怪象提供了一些理论依据。《小狗钱钱》这是一本针对儿童的理财启蒙书，书中主要一个类似童话的故事，告诉我们幸福和富足应该是我们与生俱来的权利。我们不应该以挣钱或者拥有很多金钱而感到耻辱。本书通过一只会说话的小狗给我我们讲述了一堂生动的理财课程，包括通过坚持写成功日记建立自信确定梦想，以便有挣钱的动力。同时坚持为梦想储蓄学会分配收入，使金钱变为我们的工具，做到用钱来生钱对于我这样的理财小白来说，书中并没有高深的理论，也没有具体教你如何变得富有。本书对我的作用应该是树立正确的金钱观，让我有理财意识。《福尔摩斯探案全集》这是我最近在书荒时在kindle上找到的一套特价的书，全套不到10块钱，而这套书对我来说有特殊的意义，之前又没有完全看完，因此这里我决定乘着这个机会将这套书给读完。书中的经典故事像血字研究、四签名、红发会、最后一案、巴斯克维尔的猎犬、空屋等等已经深入人心，这些故事很好的塑造了一个个性鲜明、业务能力突出的侦探形象。福尔摩斯这个形象如今已经深入人心，这些故事本身读起来也颇为有趣，有些故事即使已经了熟于心，再读一次乐趣也丝毫不减。这本书与我有着不解的渊源。它成功将我从读漫画过度到读文字类的书，同时也使我对侦探推理类小说产生了浓厚的兴趣。它使我产生了读书的爱好。同时也承载了我上中学时白嫖新华书店的美好记忆。总之如果我想培养我的孩子良好的阅读习惯，这本书将是我必定会带领他读的书。《一胜九败》由于某些特殊原因，我找到了这本书。这是一本讲述优衣库创业与主要历程的书，书中穿插了创始人柳井正对于企业经营的相关思考与理念。并且结合优衣库相关历史进行了通俗的阐述。书中以优衣库的发展历史为主线，详细讲述了从接班父亲的男士西服店，到创立优衣库，到第一家门店，再到关东第一家门店，到最后迈入全球市场。在讲述这些历史的同时也夹杂了创始人对各个时期经营理念的思考。例如店铺开遍日本时确立的以店铺为核心，总部围绕店铺运行的理念。在一定公司发展壮大的时候强调以效率为主体，要做到快的目标，并且为此成立讯销集团作为优衣库的母公司。也体现了他这一理念。需要重视人才培养，当公司成长到一定阶段就开始重视人才的培养，书中提到需要招募培养与个人价值与公司价值观相匹配的员工。对于那些不符合要求的，提出可以尊重对方的意愿离职。这对整个以终身雇用制的日本来说确实是一个先例提出在实干中成长，制定计划或者人才培养不能纸上谈兵，提倡在实际店铺中感受这一行业。广告要考虑顾客的真实需求，并且在这方面进行宣传，而不要采用猎奇、洗脑风。这个对当今中国广告业有一定的借鉴意义书中更是总结了经营者的23条理念。对于希望创业的人来说很有参考意义。对我来说，经营企业与经营自己的人生，有异曲同工之妙。例如说上说，经营者需要为企业制定大胆的经营目标。我想人生也是一样，需要为自己制定人生目标，并且为目标制定计划，并按照计划执行。而且不用担心目标是否过高，只要制定严密的可行计划，然后经常将努力之后的结果与目标进行对比、总结、更正。总能实现目标的。正如书的标题所言，经营企业经常面临的结果是一胜九败，针对失败只要认真分析失败的原因，及时止损，坚持下来总会有成功的那一天。《十分钟冥想入门指南》这是一本介绍冥想入门的书籍，最近我比较焦虑，网上推荐采用冥想可以更好的注重当下，体会当前生活。本书的作者安迪当初为了学习冥想有到喜马拉雅山脉上进行冥想训练的体验，后来成立了头脑空间项目，专注于提供冥想指导服务。科学上已经验证冥想能有效改善抑郁症和失眠症。对于缓解焦虑有一定的效果。同时经常冥想的人注意力更加集中，幸福感会增加。书中采用大量比喻说明冥想中可能会出现的问题，以及我们该如何应对，同时对冥想的相关操作和技法也有详细的描述，目前我也是处于刚入门阶段，无法判断冥想到底是否有效，我决定尝试一段时间，如果真的有效果或者我感觉比较舒适了，后续我会将冥想的相关体验以及使用的技法整理出来。《穷爸爸富爸爸》继《小狗钱钱》之后，这是我看的第二本理财的书，。书中着重强调了实现财富自由的前提就是有相应的财商，书中将财商分为拥有会计知识、法律知识、以及对金钱的正确认识。结合《小狗钱钱》这本书，我理解了金钱是我们追求幸福生活的手段而不是目的。不要耻于谈论金钱以及如何挣钱。书中指出，富人与穷人的区别并不在于挣钱的能力，而在于财商或者说对金钱的态度与认知上面。书中使用图表清晰的表述出，富人主要将挣到的钱购买资产，使用资产增值的部分进行消费。而穷人则是将大部分钱用于购买消费品。从而在失去劳动能力或者收入无法平衡支出时陷入财务危机。这与马克思所说的生产资料与生活资料有异曲同工之妙。我们应该将挣到的钱投入到购买生产资料或者能增值的资本，而不是大量用来购买生活资料。只有依靠资本的增值才能实现个人的财务自由。本书主要介绍财富观念，或者说理财的观念。对与如何理财以及如何购买股票、基金等资产提到的少之又少，甚至说没有。如果希望从中能够找到如何挑选靠谱的股票与基金或者其他理财产品，那么可能要失望了。《明朝那些事》本书是我在微信阅读中，利用上下班通勤期间读完的。读完之后我给出5星评价。给5星是因为满分只有5星。这本书是我读过的关于历史最有趣的书，书共7册，利用现代化的、俏皮的、通俗的语言，将明朝从朱元璋到朱由检的历史娓娓道来。让我看到在一个封建王朝中，士族、皇族、外戚、宦官这几股势力之间的斗争以及各种高级宫斗。同时科普了一些封建王朝中政治制度。例如科举制、三省六部制等等。不光如此，书中还包含着作者对历史的思考，同时也会有作者对像于谦、张居正、徐阶这样正直无私，充满光芒的人物的敬佩之情。也有对像魏忠贤、严嵩这样奸臣的唾弃之情。从书中的语言或者作者所占的立场来看作者与明代这些名臣一样，拥有为天下苍生谋福利的伟大的政治理想。这本书让我有这样一些感悟：原来历史、历史书也能如此有趣原来封建社会并不是皇帝一家独大，也涉及到各种政治势力之间的斗争原来好人并不是伟光正的，贪官要奸，清官要更奸原来手无缚鸡之力的文人也可以散发出如此强烈的气场原来除了戏文中，真实历史上还有这么多可歌可泣的故事原来毛主席说的路线错误知识越多越反动是对的。知识分子坏起来造成的危害比流氓更甚最后不管你是否对历史感兴趣，是男是女都可以读一下这本书。不喜欢历史的也一定会喜欢这本书。原来历史还可以如此有趣《当我谈跑步时,我谈些什么》这是我看的第一本村上春树的书，书中主要是将作者关于跑步的相关感悟以及跑步的一些历程。比如多次参加马拉松和铁人三项。从书中我读到跑步的乐趣，例如迎着清晨的微风一边欣赏美景一边跑步。在跑步时放空大脑，或者任由大脑中思绪来来去去。 另外我从书中读到作者通过跑步这件事告诉我一个自律的人是一种怎样的体验，以及如何在一件看似枯燥的事情中去寻找快乐。读完这本书后我对跑步有了一个新的认识，甚至作为一个厌恶跑步的人我也有了想要跑步的念头。《人类群星闪耀时》该书作者被誉为最会写历史的作家。书中主要采用速写的方式，快速记录了作者认为对人类历史产生深远影响的历史瞬间。我在读这本书的时候发现，很多可能在教科书中一笔带过的历史事件，在书中被描述的如此戏剧化。甚至可以说如此的惊心动魄，有时候感觉比追剧更加精彩，虽然我知道故事最终的结局是什么，但是它仍然让我产生了追剧过程中期待反转，期待故事的结局这种感觉。书中选取的历史瞬间是作者凭主观意识决定的，并不一定代表真实的历史研究，甚至很多时候的细节并不严谨。而且主要是西方历史，这对于对那段历史并不怎么理解的我来说读起来带入感并没有难么强烈，但这并不是书的缺点，反而激发了我对于某段西方历史的兴趣。《占星术杀人魔法》很早就听说过该书的大名，但是最近才有时间拜读。由于早期接触到的一些推理剧已经将书中的诡计展示的玲离尽致，在刚开始阅读时已经知晓谜底了，使这次阅读的乐趣减少了很多，但是仍然不妨碍这是一个十分优秀的诡计，该作品是一部十分优秀的推理小说。读起来仍让人觉得乐趣无穷。推理小说诡计虽然是重中之重，但是好的推理小说不能仅仅只有诡计。我想这本书除去优秀的诡计，在叙事上也十分值得称道。在阅读这部作品的时候，我时常想，我多想清除掉脑海中关于这个诡计的记忆，这样读起来会更加欲罢不能，更加令人沉醉其中。《万历十五年》该书似乎是一本严肃的历史学术著作，通过万历年间朝中的重大人物和重大事件，还原了万历朝的一些重大历史事件的全貌，展示了作者的大历史观，同时阐述了古代中国历史上以道德代替法律的种种弊端。历史人物对于历史进程的影响是如此的微小，即使是皇帝、首辅大臣、边关大吏也无法做到扭转乾坤。该书作为一本历史学术著作读起来确实有些无聊，但是不妨碍它是一本值得一读的好书《病者生存》以前就有一些疑问：既然是适者生存，那么为什么现在人类身上有如此多的不和谐呢，有如此多的遗传病和治病基因呢？这本书回答了我的一些问题。例如书中提到糖尿病层冰帮助我们的祖先度过了漫长的冰河时期，母亲在怀孕期间吃大量的垃圾食品，会使婴儿误认为外部生存条件恶劣，从而调整身体结构，对能量的消耗减少，从而更容易导致肥胖；书中提到生命是落魄的，为了生存，必须妥协。 为了让我们明天存活下来的东西，可能几十年后会要了我们的命，这就是生命的妥协。进化中也无时无刻不在发生这样的事情。另外书中也向我门展示了进化中与我们所想不一样的东西，例如进化是会受外界干扰的，并不是完全随机的。基因中有许多开关，会根据实际生存环境来调整生物性状。这也体现了生命本身对外界的一种妥协。虽然生命中存在妥协，但是我们也不需要为此沮丧，因为生命本身就是奇迹。《禅宗 六祖惠能》这是一本介绍六祖惠能大师生平的书籍，类似与人物的传记。总体来说，本书语言轻快明朗，写出了惠能生平的主要事迹，并且通过一些具体的事迹，向我展示了佛法的一些基本原理，例如心静，顿悟成佛。这些原理加上作者或者说惠能的一些心理描写，将深奥的佛法铺展开来，是我更好的理解的部分佛法。本书对了解惠能法师的生平，入门基本的佛教有一定的帮助。但是书中也有许多不足的地方，太过于唯心主义，将惠能描述为全知全能的神，有点过于神话他了。有些文字我觉得从文言中翻译为白花有点牵强。而且叙事整体结构散乱，这些都是我不太喜欢这本书的原因。《毛泽东传》之前读毛选的时候，有很多地方并没有读的很明白，毛泽东思想作为一种实用主义科学，它是一套分析问题、解决问题的方法论。要想读懂毛选，需要对毛主席的生平以及对应的历史时期有一点认识，因此我开始读这本毛泽东传书中描述了毛主席传奇而又平淡的一生。从书中可以看出毛主席的一生是斗争的一生。开始与父亲斗，后面开始封建压迫、帝国主义压迫以及国内资产阶级的压迫。建国以后又在与党内各种势力，各种思想斗争。其中有成功也有失败，从本书中可以看到毛主席并不都是英明神武的，他也只是一个普通人，也会有错误，也会迷茫，伤心之类的。从这本书中，我有点理解毛泽东思想了，它并不完全是毛泽东本人个时期的想法，而是我党在革命战争与建国初期通过实践形成的一整套科学的思想，并不完全属于毛主席，而是代表着我党不断探索实践，不断总结经验而形成的一整套思想和方法论。本书相比与其他人物传记来说，显得比较偏学术，用词比较枯燥，这也造成了阅读的过程中少了一丝趣味。但是也不失为一本了解毛主席的不错的书籍《岩田先生如是说》作为一名全新的任粉，我最近迷上了任天堂各位制作人的故事，说到各种制作人的故事，就不得不提到岩田聪社长了。这本书汇集了岩田聪公开演讲以及一些回忆录性质的内容，记录了岩田先生的一些习惯和日常。书中有几点令我十分动容，一个是岩田聪的以他人的快乐为自己的快乐，为他人的快乐而工作。还有他拿出很大一部分精力来跟每一名员工面谈。企图站在员工的立场上，为员工着想。他一直给人一种和蔼可亲的感觉，我想在聪哥手下工作应该是一件非常幸福的事情吧。另外一个地方是在他去世之后，宫本茂说“现在唯一困扰的是，我在周末想到的那些无足轻重的点子，周一没有人倾听了”。看到这里我有一种好朋友突然离我而去，再也没有人听我平日里那种碎碎念的感觉。瞬间击中了我的泪腺。聪哥在演讲中说的著名的话：”在我的名片上我是一个公司的社长。在我头脑里我是一名游戏开发者。但是在我的心里我是一名游戏玩家“。在此缅怀一直为我们带来欢乐的永远的聪哥。《睡眠革命》很早以前我听说成年人的健康睡眠时间是8小时，过去我睡觉只追求数量没有追求质量，这本书改变我关于睡眠的一些认知。书中提到一个R90方针，即人体睡眠是一个周期性的，从浅睡到深睡，再到浅睡形成多个周期，一个周期大概持续90分钟，在睡眠中需要注重的是深度睡眠的时长而不是关注总体时间。而且睡眠时间应该周期为单位而不是单纯的以小时计算。应该是90分钟的整数倍每天尽量固定起床时间，以这个固定时间来推算自己睡觉时间。应该把睡眠时间放在更长的时间范围来评估，比如评估一周一共睡了多少个90周期，而不要为某一天晚上睡眠时间不够而焦虑。同时注重白天适当的补充睡眠影响人体周期的是光，当光照不足的时候人体会产生褪黑色素让人产生睡意。光照分为强光和柔光，强光指太阳光、电子屏辐射光，而柔光则是黄光，强光会让我们更有精神，而柔光则会让我们更加舒适。所以在需要睡眠的时候放下电子产品，在卧室装上柔和的灯光，调暗家里的光线，保证你的褪黑色素的正常分泌从而产生困意。需要打起精神的时候，使用强光。例如早晨起床后打开窗帘，出去晒晒太阳，在感到倦怠的时候打开日光灯。

c++基础之变量和基本类型 之前我写过一系列的c/c++ 从汇编上解释它如何实现的博文。从汇编层面上看，确实c/c++的执行过程很清晰，甚至有的地方可以做相关优化。而c++有的地方就只是一个语法糖，或者说并没有转化到汇编中，而是直接在编译阶段做一个语法检查就完了。并没有生成汇编代码。也就是说之前写的c/c++不能涵盖它们的全部内容。而且抽象层次太低，在应用上很少会考虑它的汇编实现。而且从c++11开始，加入了很多新特性，给人的感觉就好像是一们新的编程语言一样。对于这块内容，我觉得自己的知识还是有欠缺了，因此我决定近期重新翻一翻很早以前买的《c++ primer》 学习一下，并整理学习笔记背景介绍为什么会想到再次重新学习c++的基础内容呢？目前来看我所掌握的并不是最新的c++标准，而是“c with class” 的内容，而且很明显最近在关注一些新的cpp库的时候，发现它的语法我很多地方都没见过，虽然可以根据它的写法来大致猜到它到底用了什么东西，或者说在实现什么功能，但是要自己写，可能无法写出这种语法。而且明显感觉到新的标准加入了很多现代编程语言才有的内容，比如正则表达式、lambda表达式等等。这些都让写c++变得容易，写出的代码更加易读，使其脱离了上古时期的烙印更像现代的编程语言，作为一名靠c++吃饭的程序员，这些东西必须得会的。看书、学编程总少不了写代码并编译运行它。这次我把我写代码的环境更换到了mac平台，在mac平台上使用 vim + g++的方式。这里要提一句，在mac 的shell中，g++和gcc默认使用的是4.8的版本，许多新的c++标准并不被支持，需要下载最新的编译器并使用替换环境中使用的默认编译器，使其更新到最新版本gcc / g++ 使用在shell环境中，不再像visual studio开发环境中那样，只要点击build就一键帮你编译链接生成可执行程序了。shell中所有一切都需要你使用命令行来搞定，好在gcc/g++的使用并不复杂，记住几个常用参数就能解决日常80%的使用场景了，下面罗列一些常用的命令-o 指定生成目标文件位置和名称-l 指定连接库文件名称，一般库以lib开头但是在指定名称时不用加lib前缀，例如要链接libmath.o 可以写成-lmath-L 指定库所在目录-Wall 打印所有警告，一般编译时打开这个-E 仅做预处理，不进行编译-c 仅编译，不进行链接-static 编译为静态库-share 编译为动态库-Dname=definition 预定义一个值为definition的，名称为name的宏-ggdb -level 生成调试信息，level可以为1 2 3 默认为2-g -level 生成操作系统本地格式的调试信息 -g相比于-ggdb 来说会生成额外的信息-O0/O1/O2/O3 尝试优化-Os 对生成的文件大小进行优化常用的编译命令一般是 g++ -Wall -o demo demo.cpp开启所有警告项，并编译demo.cpp 生成demo程序 ## 基本数据类型与变量 ### 算术类型 这里说的基本数据类型主要是算术类型，按占用内存空间从小到大排序 char、bool(这二者应该是相同的)、short、wchar_t、int、long、longlong、float、double、long double。当然它们有的还有有符号与无符号的区别，这里就不单独列出了 一般来说，我们脑袋中记住的它们的大小好像是固定，比如wchar_t 占2个字节，int占4个字节。单实际上c++ 并没有给这些类型的大小都定义死，而是固定了一个最小尺寸，而具体大小究竟定义为多少，不同的编译器有不同的实现，比如我尝试的wchar_t 类型在vc 编译环境中占2个字节，而g++编译出来的占4一个字节。下面的表是c++ 规定的部分类型所占内存空间大小 | 类型 | 含义 | 最小尺寸 | |:----------|:--------------|:-----| | bool | 布尔类型 | 未定义 | | char | 字符 | 8位 | | wchar_t | 宽字符 | 16位 | | char16_t | Unicode字符 | 16位 | | char32_t | Unicode字符 | 32位 | | short | 短整型 | 16位 | | int | 整型 | 32位 | | long | 长整型 | 32位 | | longlong | 长整型 | 64位 | | float | 单精度浮点数 | 32位 | | double | 双精度浮点数 | 64位 | 另外c++的标准还规定 一个int类型至少和一个short一样大，long至少和int一样大、一个longlong至少和一个long一样大。 ### 有符号数与无符号数 数字类型分为有符号和无符号的，默认上述都是有符号的，在这些类型中加入unsigned 表示无符号，而char分为 signed char、char、unsigned char 三种类型。但是实际使用是只能选有符号或者无符号的。根据编译器不同，char的表现不同。 一般在使用这些数据类型的时候有如下原则 1. 明确知晓数值不可能为负的情况下使用unsigned 类型 2. 使用int进行算数运行，如果数值超过的int的表示范围则使用 longlong类型 3. 算术表达式中不要使用char或者bool类型 4. 如果需要使用一个不大的整数，必须指定是signed char 还是unsigned char 5. 执行浮点数运算时使用double ### 类型转化 当在程序的某处我们使用了一种类型，而实际对象应该取另一种类型时，程序会自动进行类型转化，类型转化主要分为隐式类型转化和显示类型转化。 数值类型进行类型转化时，一般遵循如下规则： 1. 把数字类型转化为bool类型时，0值会转化为false，其他值最后会被转化为true 2. 当把bool转化为非bool类型时，false会转化为0，true会被转化为1 3. 把浮点数转化为整型时，仅保留小数点前面的部分 4. 把整型转化为浮点数时，小数部分为0；如果整数的大小超过浮点数表示的范围，可能会损失精度 5. 当给无符号类型的整数赋值一个超过它表示范围的数时，会发生溢出。实际值是赋值的数对最大表示数取余数的结果 6. 当给有符号的类型一个超出它表示范围的值时，具体结果会根据编译器的不同而不同 7. 有符号数与无符号数混用时，结果会自动转化为无符号数 (使用小转大的原则,尽量不丢失精度) **由于bool转化为数字类型时非0即1，注意不要在算术表达式中使用bool类型进行运算** 下面是类型转化的具体例子 ```cpp bool b = 42; // b = true int i = b; // i = 1 i = 3.14; // i = 3; double d = i; // d = 3.0 unsigned char c = -1; // c = 256 signed char c2 = c; // c2 = 0 gcc 中 255在内存中的表现形式为0xff，+1 变为0x00 并向高位溢出，所以结果为0 ``` 上述代码的最后一个语句发生了溢出，**对于像溢出这种情况下。不同的编译器有不同的处理方式，得到的结果可能不经相同，在编写代码时需要避免此类情况的出现** 尽管我们知道不给一个无符号数赋一个负数，但是经常会在不经意间犯下这样的错误，例如当一个算术表达式中既有无符号数，又有有符号数的时候。例如下面的代码 ```cpp unsigned u = 10; int i = -42; printf("%d\r\n", u + i); // -32 printf("%u\r\n", u + i); //4294967264 ``` 那么该如何计算最后的结果呢，这里直接根据它们的二进制值来进行计算，然后再转化为具体的10进制数值，例如u = 0x0000000A，i = 0xffffffd6;二者相加得到 0xffffffEO， 如果转化为int类型，最高位是1，为负数，其余各位取反然后加一得到0x20，最终的结果就是-32，而无符号，最后的值为4294967264 ### 字面值常量 一般明确写出来数值内容的称之为字面值常量，从汇编的角度来看，能直接写入代码段中数值。例如32、0xff、"hello world" 这样内容的数值 #### 整数和浮点数的字面值 整数的字面值可以使用二进制、8进制、10进制、16进制的方式给出。而浮点数一般习惯上以科学计数法的形式给出 1. 二进制以 0b开头，八进制以0开头,十六进制以0x开头 2. 数值类型的字面值常量最终会以二进制的形式写入变量所在内存，如何解释由变量的类型决定，默认10进制是带符号的数值，其他的则是不带符号的 3. 十进制的字面值类型是int、long、longlong中占用空间最小的（前提是类型能容纳对应的数值） 4. 八进制、十六进制的字面值类型是int、unsigned int、long、unsigned long、longlong和unsigned longlong 中尺寸最小的一个（同样的要求对应类型能容纳对应的数值） 5. 浮点数的字面值用小数或者科学计数法表示、指数部分用e或者E标示 #### 字符和字符串的字面值常量 由单引号括起来的一个字符是char类型的字面值，双引号括起来的0个或者多个字符则构成字符串字面值常量。字符串实际上是一个字符数组，数组中的每个元素存储对应的字符。**这个数组的大小等于字符串中字符个数加1，多出来一个用于存储结尾的\0** 有两种类型的字符程序员是不能直接使用的，一类是不可打印的字符，如回车、换行、退格等格式控制字符，另一类是c/c++语言中有特殊用途的字符，例如单引号表示字符、双引号表示一个字符串，在这些情况下需要使用转义字符. 1. 转义以\开头，后面只转义仅接着的一个字符 2. 转义可以以字符开始，也可以以数字开始，数字在最后会被转化为对应的ASCII字符 3. \x后面跟16进制数、\后面跟八进制数、八进制数只取后面的3个；十六进制数则只能取两个数值(最多表示一个字节) ```cpp '\\' // 表示一个\字符 "\"" //表示一个" "\155" //表示一个 155的8进制数，8进制的155转化为10进制为109 从acsii表中可以查到，109对应的是M "\x6D" ``` 一般来讲我们很难通过字面值常量知道它到底应该是具体的哪种类型，例如 15既可以表示short、int、long、也是是double等等类型。为了准确表达字面值常量的类型，我们可以加上特定的前缀或者后缀来修饰它们。常用的前缀和后缀如下表所示： | 前缀 | 含义 | |:------|:-----------------------| | L'' | 宽字节 | | u8"" | utf-8字符串 | | 42ULL | unsgined longlong | | f | 单精度浮点数 | | 3L | long类型 | | 3.14L | long double | | 3LL | longlong | | u'' | char16_t Unicode16字符 | | U'' | char32_t Unicode32字符 | ## 变量 变量为程序提供了有名的，可供程序操作的内存空间，变量都有具体的数据类型、所在内存的位置以及存储的具体值(即使是未初始化的变量，也有它的默认值)。变量的类型决定它所占内存的大小、如何解释对应内存中的值、以及它能参与的运算类型。在面向对象的语言中，变量和对象一般都可以替换使用 ### 变量的定义与初始化 变量的定义一般格式是类型说明符其后紧随着一个或者多个变量名组成的列表，多个变量名使用逗号隔开。最后以分号结尾。 一般在定义变量的同时赋值，叫做变量的初始化。而赋值语句结束之后，在其他地方使用赋值语句对其进行赋值，被称为赋值。从汇编的角度来看，变量的初始化是，在变量进入它的生命有效期时，对那块内存执行的内存拷贝操作。而赋值则需要分解为两条语句，一个寻址，一个值拷贝。 c++11之后支持初始化列表进行初始化，在使用初始化列表进行初始化时如果出现初始值存在精度丢失的情况时会报错 c++11之后的列表初始化语句，支持使用赋值运算幅、赋值运算符加上{}、或者直接使用{}、直接使用() ```cpp int i = 3.14; //正常 int i(3.14); //正常 int i{3.14}; //报错,使用初始化列表进行初始化时，由double到int可能会发生精度丢失 int i(3.14); //正常 ``` 如果变量在定义的时候未给定初始值，则会执行默认初始化操作，全局变量会被赋值为0，局部变量则是未初始化的状态；它的值是不确定的。这个所谓的默认初始化操作，其实并不是真的那个时候执行了什么初始化语句。全局变量被初始化为0，主要是因为，在程序加载之初，操作系统会将数据段的内存都初始化为0，而局部变量，则是在进入函数之后，初始化栈，具体初始化为何值，根据平台的不同而不同 ### 声明与定义的关系 为了允许把程序拆分为多个逻辑部分来编写，c++支持分离式编译机制，该机制允许将程序分割为若干个文件，每个文件可被独立编译。 如果将程序分为多个文件，则需要一种在文件中共享代码的方法。c++中这种方法是将声明与定义区分开来。在我之前的博客中，有对应的说明。声明只是告诉编译器这个符号可以使用，它是什么类型，占多少空间，但前对它执行的这种操作是否合法。最终会生成一个符号表，在链接的时候根据具体地址，再转化为具体的二进制代码。而定义则是真正为它分配内存空间，以至于后续可以通过一个具体的地址访问它。 声明只需要在定义语句的前面加上extern关键字。如果extern 关键字后面跟上了显式初始化语句，则认为该条语句是变量的定义语句。变量可以声明多次但是只能定义一次。另外在函数内部不允许初始化一个extern声明的变量 ```cpp int main() { extern int i = 0; //错误 return 0; } ``` 一个好的规范是声明都在放在对应的头文件中，在其他地方使用时引入该头文件，后续要修改，只用修改头文件的一个地方。一个坏的规范是，想用了，就在cpp文件中使用extern声明，这样会导致声明有多份，修改定义，其他声明都得改，项目大了，想要找起来就不那么容易了。 ### 变量作用域 变量的作用域始于声明语句，终结于声明语句所在作用域的末端 1. 局部变量在整个函数中有效 2. 普通全局变量在整个程序中都有效果 3. 花括号中定义的变量仅在这对花括号中有效 作用域可以存在覆盖，并且以最新的定义的覆盖之前的 ```cpp int i = 10; void func() { int i = 20; { string i = "hello world"; cout

记一次内存泄露调试 首先介绍一下相关背景。最近在测试一个程序时发现，在任务执行完成之后，从任务管理器上来看，内存并没有下降到理论值上。程序在启动完成之后会占用一定的内存，在执行任务的时候，会动态创建一些内存，用于存储任务的执行状态，比如扫描了哪些页面，在扫描过程中一些收发包的记录等等信息。这些中间信息在任务结束之后会被清理掉。任务结束之后，程序只会保存执行过的任务列表，从理论上讲，任务结束之后，程序此时所占内存应该与程序刚启动时占用内存接近，但是实际观察的结果就是任务结束之后，与刚启动之时内存占用差距在100M以上，这很明显不正常，当时我的第一反应是有内存泄露内存泄露排查既然有内存泄露，那么下一步就是开始排查，由于程序是采用MFC编写的，那么自然就得找MFC的内存泄露排查手段。根据网上找到的资料，MFC在DEBUG模式中可以很方便的集成内存泄露检查机制的。首先在 stdafx.h 的头文件中加入#define _CRTDBG_MAP_ALLO #include <crtdbg.h>再在程序退出的地方加入代码_CrtDumpMemoryLeaks();如果发生内存泄露的话，在调试运行结束之后，观察VS的输出情况可以看到如下内容Detected memory leaks! Dumping objects -> .\MatriXayTest.cpp(38) : {1301} normal block at 0x0000000005584D30, 40 bytes long. Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD Object dump complete.在输出中会提示有内存泄露，下面则是泄露的具体内容，MatriXayTest.cpp 是发生泄露的代码文件，括号中的38代表代码所在行数，大括号中1301代表这是程序的第1301次分配内存，或者说第1301次执行malloc操作，再往后就是内存泄露的地址，以及泄露的大小，这个地址是进程启动之后随机分配的地址，参考意义不大。下面一行表示，当前内存中的具体值，从值上来看应该是分配了内存但是没有初始化。根据这个线索，我们来排查，找到第38行所在位置int *p = new int[10]; _CrtDumpMemoryLeaks(); return nRetCode;内存泄露正是出现在new了10个int类型的数据，但是后面没有进行delete操作，正是这个操作导致了内存泄露。到此为止，检测工具也找到了，下面就是加上这段代码，运行发生泄露的程序，查看结果再漫长的等待任务执行完成并自动停止之后，我发现居然没有发现内存泄露！！！我又重复运行任务多次，发现结果是一样的，这个时候我开始怀疑是不是这个库不准，于是我在数据节点的类中添加构造函数，统计任务执行过程中创建了多少个节点，再在析构中统计析构了多少个节点，最终发现这两个数据完全相同。也就是说真的没有发生内存泄露。在这里我也疑惑了，难道是任务管理器有问题？带着这个疑问，我自己写了一段代码，在程序中不定时打印内存占用情况，结果发现虽然与任务管理器有差异，但是结果是类似的，释放之后内存并没有大幅度的下降。我带着疑问查找资料的过程的漫长过程中，发现任务管理器的显示内存占用居然降下去了，我统计了一下时间，应该是在任务结束之后的30分钟到40分钟之间。带着这个疑问，我又重新发起任务，在任务结束，并等待一定时间之后，内存占用果然降下去了。这里我得出结论 程序中执行delete操作之后，系统并不会真的立即回收操作，而是保留这个内存一定时间，以便后续该进程在需要分配时直接使用结论验证科学一般来说需要大胆假设，小心求证，既然上面根据现象做了一些猜想，下面就需要对这个猜想进行验证。首先来验证操作系统在程序调用delete之后不会真的执行delete操作。我使用下面的代码进行验证//定义一个占1M内存的结构 struct data{ char c[1024 * 1024]; } data* pa[1024] = {0}; for (int i = 0; i < 1024; i++) { pa[i] = new data; //这里执行一下数据清零操作，以便操作系统真正为程序分配内存 //有时候调用new或者malloc操作，操作系统只是保留对应地址，但是并未真正分配物理内存 //操作会等到进程真正开始操作这块内存或者进程需要分配的内存总量达到一个标准时才真正进行分配 memset(pa[i], 0x00, sizeof(data)); } printf("内存分配完毕，按任意键开始释放内存...\n"); getchar(); for (int i = 0; i < 1024; i++) { delete pa[i]; } printf("内存释放完毕,按任意键退出\n"); _CrtDumpMemoryLeaks(); char c = getchar();通过调试这段代码，在刚开始运行，没有执行到new操作的时候，进程占用内存在2M左右，运行到第一个循环结束，分配内存后，占用内存大概为1G，在执行完delete之后，内存并没有立马下降到初始的2M，而是稳定在150M左右，过一段时间之后，程序所占用内存会将到2M左右。接着对上面的代码做进一步修改，来测试内存使用时间长度与回收所需时间的长短的关系。这里仍然使用上面定义的结构体来做尝试data* pa[1024] = {0}; for (int i = 0; i < 1024; i++) { pa[i] = new data; memset(pa[i], 0x00, sizeof(data)); } printf("内存分配完毕，按任意键开始写数据到内存\n"); getchar(); //写入随机字符串 srand((unsigned) time(NULL)); DWORD dwStart = GetTickCount(); DWORD dwEnd = dwStart; printf("开始往目标内存中写入数据\n"); while ((dwEnd - dwStart) < 1 * 60 * 1000) //执行时间为1分钟 { for (int i = 0; i < 1024; i++) { for (int j = 0; j < 1024; j++) { int flag = rand() % 3; switch (flag) { case 1: { //生成大写字母 pa[i]->c[j] = (char)(rand() % 26) + 'A'; } break; case 2: { //生成小写字母 pa[i]->c[j] = (char)(rand() % 26) + 'a'; } break; case 3: { //生成数字 pa[i]->c[j] = (char)(rand() % 10) + '0'; } break; default: break; } } } dwEnd = GetTickCount(); } printf("数据写入完毕，按任意键开始释放内存...\n"); getchar(); for (int i = 0; i < 1024; i++) { delete pa[i]; } printf("内存释放完毕,按任意键退出\n"); _CrtDumpMemoryLeaks(); char c = getchar();后面就不放测试的结果了，我直接说结论，同一块内存使用时间越长，操作系统真正保留它的时间也会越长。短时间内差别可能不太明显，长时间运行，这个差别可以达到秒级甚至分。我记得当初上操作系统这门课程的时候，老师说过一句话：一个在过去使用时间越长的资源，在未来的时间内会再次使用到的概率也会越高，基于这一原理，操作会保留这块内存一段时间，如果程序在后面再次申请对应结构时，操作系统会直接将之前释放的内存拿来使用。为了验证这一现象，我来一个小的测试int *p1 = new int[1024]; memset(p, 0x00, sizeof(int) * 1024); delete[] p; int* p2= new int[1024];通过调试发现两次返回的地址相同，也就验证了之前说的内容总结最后来总结一下结论，有时候遇到delete内存后任务管理器或者其他工具显示内存占用未减少或者减少的量不对时，不一定是发生了内存泄露，也可能是操作系统的内存管理策略：程序调用delete后操作系统并没有真的立即回收对应内存，它只是暂时做一个标记，后续真的需要使用相应大小的内存时会直接将对应内存拿出来以供使用。而具体什么时候真正释放，应该是由操作系统进行宏观调控。我觉得这次暴露出来的问题还是自己基础知识掌握不扎实，如果当时我能早点回想起来当初上课时所讲的内容，可能也就不会有这次针对一个错误结论，花费这么大的精力来测试。当然这个世界上没有如果，我希望看到这篇博文的朋友，能少跟风学习新框架或者新语言，少被营销号带节奏，沉下心了，补充计算机基础知识，必将受益匪浅。

2020年回顾与2021年展望 时光荏苒，数月如梭，转眼间2020年已经过去。回顾2020年，确实有些不不容易，从年初一直持续到现在仍然不能放松警惕的新冠疫情；由疫情带来的生活上的不便，经济上的停滞不前，还有大规模的企业倒闭，资金链断裂等等问题。很庆幸我所在的公司仍然存活，我还有能力与时间在这里跟大家鬼扯一些有的没的。接下来我想按照往年的惯例开始反省过去，展望未来，给自己定一个小目标2020年回顾过去刚刚我翻看了去年这个时候写的新年规划，似乎每一个都没能实现。首先我每年都在说的要每周更新博客，甚至在年中的时候想过要更新有质量的博客，尽量减少学习笔记之类的。但是现实总是残酷的，今年似乎我除了学习笔记之外，没别的什么好写的东西。原来是想把java继续学习下去了，但是看看公司那些java代码，我完全没有兴趣，甚至浇灭了我之前燃烧起来的学习Java的热情。Java又变成我可有可无的技能了。今年疫情期间我被困武汉，而且又更换了电脑，博客之前没有导入到新的电脑上来，原本想着春节期间偷个懒，断更一周的。好家伙，这一断，直接断到年中的6月了，6月份我将之前用hexo搭建的博客环境给导入到新电脑中，然后更新了一篇类似年中总结的博客，原本打算继续更新博客，但是Java学习也停了，自己在疫情期间也沉迷游戏无法自拔，周末养成了打游戏的习惯，博客一直断更，之前腾讯云社区的小编，联系过我，劝我更新博客，我以工作忙为理由，说服了自己断更，现在想想有点后悔把，所以新年的第一步就是把博客继续更新下去，在这里我也不纠结与是否是高质量的干货了，还是按照之前的路子，学习笔记加上工作总结，供自己翻阅之用，如果有幸能帮助到大家自然也是不甚荣幸。我也不知道为什么，会产生了想要练字的冲动，随着这个冲动，我买了一整套字帖，田字格的纸以及钢笔，当初坚持到了10月份，每天练习一小时，后来没有进展。我自己也已耽误学习为由放弃了。如今已经搁置了快3个月了，现在想想有点惭愧，放弃练字省下的时间我似乎并没有拿去做什么正事，学习仍然搁置，游戏照打不误，省下了的这个时间似乎不是消耗在手机上就是消耗在ns上。工作上没了目标，也变的唯唯诺诺，做事不求更好，只求按时完成，甚至在工作上开始花大把的时间摸鱼，太多时间花在手机和逛论坛上，美其名曰学习新新技术，但是很多都是看过了，知道了这个名字，没有花时间去深究它究竟该用在哪种场合，有什么优缺点，甚至连官方demo都没有运行过。这个也是浪费了大量时间。后续当然需要浏览论坛，但是得改变策略了，碰到感兴趣的，或者觉得有用的，应该先记下来，后续花成块的时间去仔细研究它，甚至考虑在项目上使用它，达到学以致用的目的项目上就不说了，从年中开始，没有做过任何新的项目，仍然在针对老的项目做一些优化，功能上的提升，这个部分似乎没有什么很大感触或者有什么好的经验可以聊的。今年陆陆续续有很多想学的，最开始想学Django，并且写了一个博客的demo，但是使用起来效果太差，没有开源的好用，所以就放弃了。后来想学emacs，但是elisp这块几乎没有什么进步，到现在仍然无法很好的改造emac，反倒是用起来的开箱即用的vs code，这个也算是失败了把。后面在分析c++的开源代码时，发现自己一直自诩为c++的高级程序员，但是连c++11有的标准都不会用，看不明白，这也导致我想要重新学习c++11以及以后的标准，这个是目前仍然在坚持，但是进度很慢的事，在学习过程中，我发现自己开始慢慢建立面向对象的概念，对对象、容器、迭代、数据类型这些有了新的认识，我记得当时写Java相关的博客时说过，Java是面向对象的代表，能给你关于对象的完整性认识，但是现在我想不光Java是，c++其实也是。Java能带来的思想上的转变，c++当然也能，如果你没有这个感觉，只能说学习的不够深入，就好像我学了elisp，对函数式编程没有什么感觉，就是我自己elisp不过关。在读书上，我的进度似乎并没有比往年快多少，仍然是睡前读读书，促进睡眠而已，有的读过似乎就忘记了，没有什么感悟，没觉得有网上吹的那么神，这个应该是自己完全没有读进去，只是机械的读书中的文字，到底有多少化为自己的思考，或者成为自己的养料的，这个我也不清楚在学习上除了这些花的时间比较长之外，我中间也陆续的尝试学习了go、rust、lua、c#。但是这些我在很短的时间内就放弃了，也就不提了2021年的小目标整个2020就这样稀里糊涂的就过去了，想学的东西很多，但是花的时间却很少，我想在每个上面都分配时间，然后全方位开花的方针并不合适我，我还是喜欢把时间集中消耗在某一件事情上，说的再明白点，我自己脑袋性能不够，是一个单核的cpu,无法做到多线程切换，强制使用线程，只会造成性能的损失。基于上述反思，与自我认知，我决定指定如下计划：学习上，将想学的东西列清单，并给出一个小目标，比如做一个项目，不达目标就不进行下一个内容的学习。实在有问题的，写悔过书，详细分析为啥不行。不强求一定得学，但是也不能轻易放弃记录自己学习的过程形成笔记，作为博客发出，博客这块仍然坚持每周更新读书上，我准备开一个书评的文章，每读完一本，在博客上更新关于它的简短的读后感。坚持睡前读书。锻炼，NS上的我最近刚买了《有氧拳击》，既然自己不喜欢健身房那种人多的场合，就自己在加默默打拳，记录自己的体重与运动量。好好锻炼减肥工作上不急于完成工作，希望自己动手前认真思考一下，如何更优雅的实现功能。写出更容易被理解的代码与文档工作上及时总结，中间的经验、处理的问题、搜索到的资料进行整理形成博客少玩游戏，少熬夜、坚持每天早起半小时（多了估计也坚持不下来）目前能想到的就是这些，在这里给各位愿意看到最后的朋友送上迟到的新年祝福，预祝各位心想事成，早日脱单，最后再祝各位新年大吉吧（别问为什么又是这句，问就是没文化，想不出什么高级词汇，再问就是我就是喜欢玩老梗）

记一次失败的项目经历 最近因为疫情原因一直在家，已经有快半年没有更新博客了，最近返回公司上班之后，去年做的项目已经完结，虽然已成功交付用户使用，但是在我看来这仍然是失败项目，在这里我想回顾这些经历，算是给后面的自己一个警醒吧为何说这是一个失败的项目我一直认为这是一个失败的项目，原因有如下几点：项目为能如期交付，原定计划是在2月份交付并发行1.0稳定版，但是由于种种原因推迟到了6月1号，延期了快半年项目到后期难以维护，在后期代码复杂度上升了不止一个层次，给维护与扩展带来了不小的麻烦项目质量无法达到预期效果，在发布之时仍有部分隐藏bug，没有经过细致的测试，为了按时交付，很多测试工作都省略了，目前只进行了两轮测试。功能有些无法达到预期效果，当初为了赶进度很多不重要的功能也是能省则省，有些需求并没有很好的实现项目中存在的一些问题前期需求设计不合理：早期立项的时候，我参考了许多类似的产品、与相关同事进行过探讨，但是由于经验不足，没有相关产品的开发与使用经验，导致许多需求设计不太合理，后续变更需求频繁，甚至出现过回炉重造的情况，这个主要责任在我这边，当时很多需求是我自己一拍脑门想起来觉得这样做可能符合客户需要，但是没有跟其他人进行商量，导致在后续实施时要么是在此基础上无法实施，或者成为鸡肋功能影响后续工作。后续需求变更频繁：后续需求变更频繁，很多时候老板看过项目之后觉得哪块不好会直接提出来，比如某些功能不合理，某些地方配色，页面布局不合理之类的。测试人员会在测试实际使用中告知他们想要某个功能，以便更方便的使用与测试。但是这些变更往往是在后期开发已经完成，正式进入测试流程中时提出，给后续开发与维护造成很多不必要的麻烦。这种情况的主要问题在于老板与测试人员在早期需求制定时参与过少，以及我本身对这方面不够专业。导致出现后期疯狂修改需求的情况需求记录不及时：在前期需求设计时我会详细记录需求的相关内容与演示效果，但是后续开发任务紧张，需求变更频繁，无法有充足的时间进行需求变更的记录，很多时候都是老板或者测试人员口述，然后由开发人员进行修改，没有合理的需求评审，没有详细的记录，有时候时间一长自己都给忘了当初是如何制定的。后续无法复盘架构设计问题：还是由于自己当初经验不足，当时考虑到用户可能需要二次开发，所以规定当时所有的功能都采用restful-API的形式，并且前端采用纯粹的ajax请求直接调用后台接口，但是有些功能确实不太适合做成接口，而且对于前端大家都不了解的情况下没有使用常用的前端界面框架，而纯粹采用自己编写的方式造成大量的时间浪费与遗留无法解决的bug。这些都给项目造成了不小的麻烦；没有详细设计：当初项目留给前期设计的时间并不充足，按照一般软件功能的流程来说，重要的时间应该留给前期设计，编码与测试只占极少数部分，而在这个项目进行过程中，完全颠倒过来了，不到一个月完成前期的需求与详细设计以及开发测试的分工，和接近3个月的开发与测试。导致的结果就是代码臃肿，很多公共功能没有抽象为具体的函数，重复代码过多，代码结构混乱无法进行后续维护。也就是说我们项目一开始就早就出了一个屎山。分工不合理：在前期设计与开发环境框架制定完成之后，进入到分工环节，在这个环节中出现分工不够合理的问题。主要体现在我自己不清楚员工的能力与擅长的部分，在制定计划时采用平均分配的方式没有考虑需求难度与员工自身的能力相结合。导致后续能力强的员工快速完成任务而存在空闲时间，而能力一般的往往会拖慢进度，或者对于困难需求实现的也是差强人意。或者出现能力强的员工去帮助能力一般的员工完成剩余需求，出现能者多劳但是无法多得的情况。测试与验收问题：在早期设计阶段并没有完整的测试计划，测试一直推迟到开发完成之后，在那个时候发现想要详细测试时间不够、测试出来的bug由于设计等原因难以修改、甚至出现某些地方使用不太合理又要新加需求的情况，这些都导致无限期的加班与代码修改，代码越改越乱，人心烦躁，开发与测试怨声载道。后续该如何改进培养自己的产品思维：早期需求制定的不合理，我自身有很大的原因，我由于本职工作是做开发的，很多时候在设计需求时采用的是开发者的思维方式，而没有站在用户角度，设计出来的系统在后续测试中会发现很难用，没有合理的引导，功能过于分散，常用功能操作不够简单，操作步骤过多等情况时有发生，为了用户必须得改需求。我想自己得加强这方面的素养，设计完成之后少改需求制定规范的需求管理制度：在需求制定、变更、实现、验收这些过程，在项目中没有与很好的得到解决和管理，造成很多需求后续无法查证，不合理的需求无法定位到具体的责任人，甚至谁都可以提需求。为了解决需求相关的问题，需要引入规范的需求管理制度，加入需求评审等操作，让需求更合理，更有迹可循。延长早期设计时间：在大学中学习软件工程相关课程时，我的老师告诉我，在项目开发中，编码只占很少一部分，而现在似乎反过来了，编码占据了时间的大头，而前期设计只是为了给开发人员安排工作而已。我想一个成功的项目应该是会在前期设计过程中下了很大的功夫的。可以在前期多进行相关会议，比如需求评审、针对需求进行测试用例的评审、开发框架与相关方案的评审、以及工作计划的合理安排等等。规范开发中的代码审查机制：员工的能力，与代码编写风格对项目的可维护性有巨大的影响，过去我一直觉得开发人员应该保留自己的个性，编写能体现能力的牛X的代码，但是经过几次与他人合作、带领团队开发项目之后，我改变了这个看法，作为底层的码农，为了项目的统一于可维护性，最好还是安心做一颗螺丝钉，多人合作不需要个性，一切为了项目才是正道。所以在后续如果还有项目需要我带队开发，我会统一编码格式与注释格式，像大厂那样制定编码规范，甚至细微到如何给变量、函数、类命名等等。最好每天下班前一次 code review，及时消除冗余代码、不规范的代码、不合理的功能，特别是同一个功能，多个人编写函数，函数的参数列表与实现完全不同的情况。测试与开发并行的机制：之前测试永远是等到所有开发任务完成之后进行，一旦项目完结，进入维护节点，要修改bug是相当困难，而且是牵一发而动全身的，测试应该与开发并行，在需求评审时应该做到给出需求验收标准与对应的测试用例，而且需要配合代码审查，提醒开发人员针对每一个功能函数编写单元测试。需求完成之后立即对照测试用例进行测试，保证每个需求都准确无误。更加合理的工作安排：合理安排工作，需要做到针对员工的能力和需求评审时得出的需求的难度来合理安排，合理安排包括合理的时间、合理的人员与合理的需求安排等等。这个可能没有相应的参考标准，只能根据经验来判断了。自己应该更加投入到这个项目中：由于我在公司待的时间较长，对公司业务比较熟悉，所以很多时候总有人会来问问题、商量某些事，我一贯又是一个老好人的态度，甚至有时候做到事无巨细都亲自动手。甚至公司主要产品也需要我来进行维护，而且由于项目人手不够，我也参与到项目的具体开发与测试工作之中，导致长时间都消耗在无意义的事情之上，无法专注于项目管理工作上。在后面项目需要做需求变更、更改开发计划时无法及时记录与评审；看到不合理的代码没有时间做code review、提取公共部分，重构部分代码，这些工作都由于没有时间而暂时搁置了。在后面项目越发的超出我的掌控。以上就是之前带队开发时出现的问题以及一些反思，如果后面还有机会作为项目的leader，我想尽量避免这些情况。更加专注于项目。制定相关制度，保证项目质量。

使用Python调用Nessus 接口实现自动化扫描 之前在项目中需要接入nessus扫描器，研究了一下nessus的api，现在将自己的成果分享出来。Nessus提供了丰富的二次开发接口，无论是接入其他系统还是自己实现自动化扫描，都十分方便。同时Nessus也提供了完备的API文档，可以在 Settings->My Account->API Keys->API documentation认证nessus提供两种认证方式，第一种采用常规的登录后获取token的方式，在https://localhost:8834/api#/resources/session条目中可以找到这种方式，它的接口定义如下:POST /session { "username":{string}, "password":{string} }输入正确的用户名和密码，登录成功后会返回一个token{ "token": {string} }在后续请求中，将token放入请求头信息中请求头的key为X-Cookie，值为 token=xxxx，例如 :X-Cookie: token=5fa3d3fd97edcf40a41bb4dbdfd0b470ba45dde04ebc37f8;，下面是获取任务列表的例子import requests import json def get_token(ip, port, username, password): url = "https://{0}:{1}/session".format(ip, port) post_data = { 'username': username, 'password': password } respon = requests.post(url, data=post_data, verify=False) if response.status_code == 200: data = json.loads(response.text) return data["token"] def get_scan_list() # 这里ip和port可以从配置文件中读取或者从数据库读取，这里我省略了获取这些配置值得操作 url = "https://{ip}:{port}/scans".format(ip, port) token = get_token(ip, port, username, password) if token: header = { "X-Cookie":"token={0}".format(token), "Content-Type":"application/json" } response = requests.get(url, headers=header, verify=False) if response.status_code == 200: result = json.loads(respon.text) return result第二种方式是使用Nessus生成的API Key，这里我们可以依次点击 Settings->My Account->API Keys-->Generate按钮，生成一个key，后续使用时填入头信息中，还是以获取扫描任务列表作为例子def get_scan_list() accessKey = "XXXXXX" #此处填入真实的内容 secretKey = "XXXXXX" #此处填入真实内容 url = "https://{ip}:{port}/scans".format(ip, port) token = get_token(ip, port, username, password) if token: header = { 'X-ApiKeys': 'accessKey={accesskey};secretKey={secretkey}'.format(accesskey=accessKey, secretkey=secretKey) "Content-Type":"application/json" } response = requests.get(url, headers=header, verify=False) if response.status_code == 200: result = json.loads(respon.text) return result对比来看使用第二种明显方便一些，因此后续例子都采用第二种方式来呈现策略模板配置策略模板的接口文档在 https://localhost:8834/api#/resources/policies 中。创建策略模板创建策略模板使用的是 策略模板的create接口，它里面有一个必须填写的参数 uuid 这个参数是一个uuid值，表示以哪种现有模板进行创建。在创建之前需要先获取系统中可用的模板。获取的接口是 /editor/{type}/templates,type 可以选填policy或者scan。这里我们填policy一般我们都是使用模板中的 Advanced 来创建，如下图下面是获取该模板uuid的方法，主要思路是获取系统中所有模板，然后根据模板名称返回对应的uuid值def get_nessus_template_uuid(ip, port, template_name = "advanced"): header = { 'X-ApiKeys': 'accessKey={accesskey};secretKey={secretkey}'.format(accesskey=accesskey, secretkey=secretkey), 'Content-type': 'application/json', 'Accept': 'text/plain'} api = "https://{ip}:{port}/editor/scan/templates".format(ip=ip, port=port) response = requests.get(api, headers=header, verify=False) templates = json.loads(response.text)['templates'] for template in templates: if template['name'] == template_name: return template['uuid'] return None有了这个id之后，下面来创建策略模板,这个接口的参数较多，但是很多参数都是选填项。这个部分文档写的很简陋，很多参数不知道是干嘛用的，当时我为了搞清楚每个参数的作用，一个个的尝试，然后去界面上看它的效果，最后终于把我感兴趣的给弄明白了。 它的主体部分如下:{ "uuid": {template_uuid}, "audits": { "feed": { "add": [ { "id": {audit_id}, "variables": { "1": {audit_variable_value}, "2": {audit_variable_value}, "3": {audit_variable_value} } } ] } }, "credentials": { "add": { {credential_category}: { {credential_name}: [ { {credential_input_name}: {string} } ] } } }, "plugins": { {plugin_family_name}: { "status": {string}, "individual": { {plugin_id}: {string} } } }, "scap": { "add": { {scap_category}: [ { {scap_input_name}: {string} } ] } }, "settings": { "acls": [ permission Resource ], //其他的减值对，这里我将他们都省略了 }他们与界面上配置的几个大项有对应关系，能对应的上的我给做了标记，但是有的部分对应不上。settings 是给策略模板做基础配置的，包括配置扫描的端口范围，服务检测范围等等。credentials 是配置登录扫描的，主要包括 windows、ssh、telnet等等plugins 配置扫描使用的插件，例如服务扫描版本漏洞等等在settings中，对应关系如下图所示下面是创建扫描策略模板的实际例子:def create_template(ip, port, **kwargs): # kwargs 作为可选参数，用来配置settings和其他项 header = { "X-ApiKeys": "accessKey={accesskey};secretKey={secretkey}".format(accesskey=accesskey, secretkey=secretkey), "Content-Type": "application/json", "Accept": "text/plain" } policys = {} # 这里 grouppolicy_set 存储的是策略模板中各个脚本名称以及脚本是否启用的信息 for policy in grouppolicy_set: enabled = "enabled" if policy.enable else "disabled" policys[policy.name] = { "status": enabled } # settings里面的各小项必须得带上，否则会创建不成功 "settings": { "name": template.name, "watchguard_offline_configs": "", "unixfileanalysis_disable_xdev": "no", "unixfileanalysis_include_paths": "", "unixfileanalysis_exclude_paths": "", "unixfileanalysis_file_extensions": "", "unixfileanalysis_max_size": "", "unixfileanalysis_max_cumulative_size": "", "unixfileanalysis_max_depth": "", "unix_docker_scan_scope": "host", "sonicos_offline_configs": "", "netapp_offline_configs": "", "junos_offline_configs": "", "huawei_offline_configs": "", "procurve_offline_configs": "", "procurve_config_to_audit": "Saved/(show config)", "fortios_offline_configs": "", "fireeye_offline_configs": "", "extremeos_offline_configs": "", "dell_f10_offline_configs": "", "cisco_offline_configs": "", "cisco_config_to_audit": "Saved/(show config)", "checkpoint_gaia_offline_configs": "", "brocade_offline_configs": "", "bluecoat_proxysg_offline_configs": "", "arista_offline_configs": "", "alcatel_timos_offline_configs": "", "adtran_aos_offline_configs": "", "patch_audit_over_telnet": "no", "patch_audit_over_rsh": "no", "patch_audit_over_rexec": "no", "snmp_port": "161", "additional_snmp_port1": "161", "additional_snmp_port2": "161", "additional_snmp_port3": "161", "http_login_method": "POST", "http_reauth_delay": "", "http_login_max_redir": "0", "http_login_invert_auth_regex": "no", "http_login_auth_regex_on_headers": "no", "http_login_auth_regex_nocase": "no", "never_send_win_creds_in_the_clear": "yes" if kwargs["never_send_win_creds_in_the_clear"] else "no", "dont_use_ntlmv1": "yes" if kwargs["dont_use_ntlmv1"] else "no", "start_remote_registry": "yes" if kwargs["start_remote_registry"] else "no", "enable_admin_shares": "yes" if kwargs["enable_admin_shares"] else "no", "ssh_known_hosts": "", "ssh_port": kwargs["ssh_port"], "ssh_client_banner": "OpenSSH_5.0", "attempt_least_privilege": "no", "region_dfw_pref_name": "yes", "region_ord_pref_name": "yes", "region_iad_pref_name": "yes", "region_lon_pref_name": "yes", "region_syd_pref_name": "yes", "region_hkg_pref_name": "yes", "microsoft_azure_subscriptions_ids": "", "aws_ui_region_type": "Rest of the World", "aws_us_east_1": "", "aws_us_east_2": "", "aws_us_west_1": "", "aws_us_west_2": "", "aws_ca_central_1": "", "aws_eu_west_1": "", "aws_eu_west_2": "", "aws_eu_west_3": "", "aws_eu_central_1": "", "aws_eu_north_1": "", "aws_ap_east_1": "", "aws_ap_northeast_1": "", "aws_ap_northeast_2": "", "aws_ap_northeast_3": "", "aws_ap_southeast_1": "", "aws_ap_southeast_2": "", "aws_ap_south_1": "", "aws_me_south_1": "", "aws_sa_east_1": "", "aws_use_https": "yes", "aws_verify_ssl": "yes", "log_whole_attack": "no", "enable_plugin_debugging": "no", "audit_trail": "use_scanner_default", "include_kb": "use_scanner_default", "enable_plugin_list": "no", "custom_find_filepath_exclusions": "", "custom_find_filesystem_exclusions": "", "reduce_connections_on_congestion": "no", "network_receive_timeout": "5", "max_checks_per_host": "5", "max_hosts_per_scan": "100", "max_simult_tcp_sessions_per_host": "", "max_simult_tcp_sessions_per_scan": "", "safe_checks": "yes", "stop_scan_on_disconnect": "no", "slice_network_addresses": "no", "allow_post_scan_editing": "yes", "reverse_lookup": "no", "log_live_hosts": "no", "display_unreachable_hosts": "no", "report_verbosity": "Normal", "report_superseded_patches": "yes", "silent_dependencies": "yes", "scan_malware": "no", "samr_enumeration": "yes", "adsi_query": "yes", "wmi_query": "yes", "rid_brute_forcing": "no", "request_windows_domain_info": "no", "scan_webapps": "no", "start_cotp_tsap": "8", "stop_cotp_tsap": "8", "modbus_start_reg": "0", "modbus_end_reg": "16", "hydra_always_enable": "yes" if kwargs["hydra_always_enable"] else "no", "hydra_logins_file": "" if kwargs["hydra_logins_file"] else kwargs["hydra_logins_file"], # 弱口令文件需要事先上传，后面会提到上传文件接口 "hydra_passwords_file": "" if kwargs["hydra_passwords_file"] else kwargs["hydra_passwords_file"], "hydra_parallel_tasks": "16", "hydra_timeout": "30", "hydra_empty_passwords": "yes", "hydra_login_as_pw": "yes", "hydra_exit_on_success": "no", "hydra_add_other_accounts": "yes", "hydra_postgresql_db_name": "", "hydra_client_id": "", "hydra_win_account_type": "Local accounts", "hydra_win_pw_as_hash": "no", "hydra_cisco_logon_pw": "", "hydra_web_page": "", "hydra_proxy_test_site": "", "hydra_ldap_dn": "", "test_default_oracle_accounts": "no", "provided_creds_only": "yes", "smtp_domain": "example.com", "smtp_from": "[email protected]", "smtp_to": "postmaster@[AUTO_REPLACED_IP]", "av_grace_period": "0", "report_paranoia": "Normal", "thorough_tests": "no", "detect_ssl": "yes", "tcp_scanner": "no", "tcp_firewall_detection": "Automatic (normal)", "syn_scanner": "yes", "syn_firewall_detection": "Automatic (normal)", "wol_mac_addresses": "", "wol_wait_time": "5", "scan_network_printers": "no", "scan_netware_hosts": "no", "scan_ot_devices": "no", "ping_the_remote_host": "yes", "tcp_ping": "yes", "icmp_unreach_means_host_down": "no", "test_local_nessus_host": "yes", "fast_network_discovery": "no", "arp_ping": "yes" if kwargs["arp_ping"] else "no", "tcp_ping_dest_ports": kwargs["tcp_ping_dest_ports"], "icmp_ping": "yes" if kwargs["icmp_ping"] else "no", "icmp_ping_retries": kwargs["icmp_ping_retries"], "udp_ping": "yes" if kwargs["udp_ping"] else "no", "unscanned_closed": "yes" if kwargs["unscanned_closed"] else "no", "portscan_range": kwargs["portscan_range"], "ssh_netstat_scanner": "yes" if kwargs["ssh_netstat_scanner"] else "no", "wmi_netstat_scanner": "yes" if kwargs["wmi_netstat_scanner"] else "no", "snmp_scanner": "yes" if kwargs["snmp_scanner"] else "no", "only_portscan_if_enum_failed": "yes" if kwargs["only_portscan_if_enum_failed"] else "no", "verify_open_ports": "yes" if kwargs["verify_open_ports"] else "no", "udp_scanner": "yes" if kwargs["udp_scanner"] else "no", "svc_detection_on_all_ports": "yes" if kwargs["svc_detection_on_all_ports"] else "no", "ssl_prob_ports": "Known SSL ports" if kwargs["ssl_prob_ports"] else "All ports", "cert_expiry_warning_days": kwargs["cert_expiry_warning_days"], "enumerate_all_ciphers": "yes" if kwargs["enumerate_all_ciphers"] else "no", "check_crl": "yes" if kwargs["check_crl"] else "no", } credentials = { "add": { "Host": { "SSH": [], "SNMPv3": [], "Windows": [], }, "Plaintext Authentication": { "telnet/rsh/rexec": [] } } } try: if kwargs["snmpv3_username"] and kwargs["snmpv3_port"] and kwargs["snmpv3_level"]: level = kwargs["snmpv3_level"] if level == NessusSettings.LOW: credentials["add"]["Host"]["SNMPv3"].append({ "security_level": "No authentication and no privacy", "username": kwargs["snmpv3_username"], "port": kwargs["snmpv3_port"] }) elif level == NessusSettings.MID: credentials["add"]["Host"]["SNMPv3"].append({ "security_level": "Authentication without privacy", "username": kwargs["snmpv3_username"], "port": kwargs["snmpv3_port"], "auth_algorithm": NessusSettings.AUTH_ALG[kwargs["snmpv3_auth"][1]], "auth_password": kwargs["snmpv3_auth_psd"] }) elif level == NessusSettings.HIGH: credentials["add"]["Host"]["SNMPv3"].append({ "security_level": "Authentication and privacy", "username": kwargs["snmpv3_username"], "port": kwargs["snmpv3_port"], "auth_algorithm": NessusSettings.AUTH_ALG[kwargs["snmpv3_auth"]][1], "auth_password": kwargs["snmpv3_auth_psd"], "privacy_algorithm": NessusSettings.PPIVACY_ALG[kwargs["snmpv3_hide"]][1], "privacy_password": kwargs["snmpv3_hide_psd"] }) if kwargs["ssh_username"] and kwargs["ssh_psd"]: credentials["add"]["Host"]["SSH"].append( { "auth_method": "password", "username": kwargs["ssh_username"], "password": kwargs["ssh_psd"], "elevate_privileges_with": "Nothing", "custom_password_prompt": "", }) if kwargs["windows_username"] and kwargs["windows_psd"]: credentials["add"]["Host"]["Windows"].append({ "auth_method": "Password", "username": kwargs["windows_username"], "password": kwargs["windows_psd"], "domain": kwargs["ssh_host"] }) if kwargs["telnet_username"] and kwargs["telnet_password"]: credentials["add"]["Plaintext Authentication"]["telnet/rsh/rexec"].append({ "username": kwargs["telnet_username"], "password": kwargs["telnet_password"] }) data = { "uuid": get_nessus_template_uuid(terminal, "advanced"), "settings": settings, "plugins": policys, "credentials": credentials } api = "https://{0}:{1}/policies".format(ip, port) response = requests.post(api, headers=header, data=json.dumps(data, ensure_ascii=False).encode("utf-8"), # 这里做一个转码防止在nessus端发生中文乱码 verify=False) if response.status_code == 200: data = json.loads(response.text) return data["policy_id"] # 返回策略模板的id，后续可以在创建任务时使用 else: return None策略还有copy、delete、config等操作，这里就不再介绍了，这个部分主要弄清楚各参数的作用，后面的这些接口使用的参数都是一样的任务任务部分的API 在https://localhost:8834/api#/resources/scans 中创建任务创建任务重要的参数如下说明如下:uuid: 创建任务时使用的模板id，这个id同样是我们上面说的系统自带的模板idname：任务名称policy_id：策略模板ID，这个是可选的，如果要使用上面我们自己定义的扫描模板，需要使用这个参数来指定，并且设置上面的uuid为 custom 的uuid，这个值表示使用用户自定义模板；当然如果就想使用系统提供的，这个字段可以不填text_targets：扫描目标地址，这个参数是一个数组，可以填入多个目标地址，用来一次扫描多个主机创建任务的例子如下:def create_task(task_name, policy_id, hosts): # host 是一个列表，存放的是需要扫描的多台主机 uuid = get_nessus_template_uuid(terminal, "custom") # 获取自定义策略的uuid if uuid is None: return False data = {"uuid": uuid, "settings": { "name": name, "policy_id": policy_id, "enabled": True, "text_targets": hosts, "agent_group_id": [] }} header = { 'X-ApiKeys': 'accessKey={accesskey};secretKey={secretkey}'.format(accesskey=accesskey, secretkey=secretkey), 'Content-type': 'application/json', 'Accept': 'text/plain'} api = "https://{ip}:{port}/scans".format(ip=terminal.ip, port=terminal.port) response = requests.post(api, headers=header, data=json.dumps(data, ensure_ascii=False).encode("utf-8"), verify=False) if response.status_code == 200: data = json.loads(response.text) if data["scan"] is not None: scan = data["scan"] # 新增任务扩展信息记录 return scan["id"] # 返回任务id启动/停止任务启动任务的接口为 POST /scans/{scan_id}/launch scan_id 是上面创建任务返回的任务ID, 它有个可选参数 alt_targets,如果这个参数被指定，那么该任务可以扫描这个参数中指定的主机，而之前创建任务时指定的主机将被替代停止任务的接口为: POST /scans/{scan_id}/stop下面给出启动和停止任务的方法def start_task(task_id, hosts): header = { 'X-ApiKeys': 'accessKey={accesskey};secretKey={secretkey}'.format(accesskey=accesskey, secretkey=secretkey), 'Content-type': 'application/json', 'Accept': 'text/plain'} data = { "alt_targets": [hosts] # 重新指定扫描地址 } api = "https://{ip}:{port}/scans/{scan_id}/launch".format(ip=ip, port=port, scan_id=scan_id) response = requests.post(api, data=data, verify=False, headers=header) if response.status_code != 200: return False else: return True def stop_task(task_id): header = { 'X-ApiKeys': 'accessKey={accesskey};secretKey={secretkey}'.format(accesskey=terminal.reserved1, secretkey=terminal.reserved2), 'Content-type': 'application/json', 'Accept': 'text/plain'} api = "https://{ip}:{port}/scans/{scan_id}/stop".format(ip=ip, port=port, task_id) response = requests.post(api, headers=header, verify=False) if response.status_code == 200 or response.status_code == 409: # 根据nessus api文档可以知道409 表示任务已结束 return True return False获取扫描结果使用接口 GET /scans/{scan_id} 可以获取最近一次扫描的任务信息，从接口文档上看，它还可以获取某次历史扫描记录的信息，如果不填这个参数，接口中会返回所有历史记录的id。如果不填历史记录id，那么会返回最近一次扫描到的漏洞信息，也就是说新扫描到的信息会把之前的信息给覆盖下面是返回信息的部分说明{ "info": { "edit_allowed": {boolean}, "status": {string}, //当前状态 completed 字符串表示结束，cancel表示停止 "policy": {string}, "pci-can-upload": {boolean}, "hasaudittrail": {boolean}, "scan_start": {string}, "folder_id": {integer}, "targets": {string}, "timestamp": {integer}, "object_id": {integer}, "scanner_name": {string}, "haskb": {boolean}, "uuid": {string}, "hostcount": {integer}, "scan_end": {string}, "name": {string}, "user_permissions": {integer}, "control": {boolean} }, "hosts": [ //按主机区分的漏洞信息 host Resource ], "comphosts": [ host Resource ], "notes": [ note Resource ], "remediations": { "remediations": [ remediation Resource ], "num_hosts": {integer}, "num_cves": {integer}, "num_impacted_hosts": {integer}, "num_remediated_cves": {integer} }, "vulnerabilities": [ vulnerability Resource //本次任务扫描到的漏洞信息 ], "compliance": [ vulnerability Resource ], "history": [ history Resource //历史扫描信息，可以从这个信息中获取历史记录的id ], "filters": [ filter Resource ] }这个信息里面vulnerabilities和host里面都可以拿到漏洞信息，但是 vulnerabilities中是扫描到的所有漏洞信息，而host则需要根据id再次提交请求，也就是需要额外一次请求，但它是按照主机对扫描到的漏洞进行了分类。而使用vulnerabilities则需要根据漏洞信息中的host_id 手工进行分类下面是获取任务状态的示例:def get_task_status(task_id): header = { "X-ApiKeys": "accessKey={accesskey};secretKey={secretkey}".format(accesskey=accesskey, secretkey=secretkey), "Content-Type": "application/json", "Accept": "text/plain" } api = "https://{ip}:{port}/scans/{task_id}".format(ip=ip, port=port, task_id=task_id) response = requests.get(api, headers=header, verify=False) if response.status_code != 200: return 2, "Data Error" data = json.loads(response.text) hosts = data["hosts"] for host in hosts: get_host_vulnerabilities(scan_id, host["host_id"]) # 按主机获取漏洞信息 if data["info"]["status"] == "completed" or data["info"]["status"] =='canceled': # 已完成,此时更新本地任务状态 return 1, "OK"获取漏洞信息在获取任务信息中，已经得到了本次扫描中发现的弱点信息了，只需要我们解析这个json。它具体的内容如下："host_id": {integer}, //主机id "host_index": {string}, "hostname": {integer},//主机名称 "progress": {string}, //扫描进度 "critical": {integer}, //危急漏洞数 "high": {integer}, //高危漏洞数 "medium": {integer}, //中危漏洞数 "low": {integer}, //低危漏洞数 "info": {integer}, //相关信息数目 "totalchecksconsidered": {integer}, "numchecksconsidered": {integer}, "scanprogresstotal": {integer}, "scanprogresscurrent": {integer}, "score": {integer}根据主机ID可以使用 GET /scans/{scan_id}/hosts/{host_id} 接口获取主机信息，它需要两个参数，一个是扫描任务id，另一个是主机id。下面列举出来的是返回值得部分内容，只列举了我们感兴趣的部分:{ "info": { "host_start": {string}, "mac-address": {string}, "host-fqdn": {string}, "host_end": {string}, "operating-system": {string}, "host-ip": {string} }, "vulnerabilities": [ { "host_id": {integer}, //主机id "hostname": {string}, //主机名称 "plugin_id": {integer}, //策略id "plugin_name": {string}, //策略名称 "plugin_family": {string}, //所属策略组 "count": {integer}, //该种漏洞数 "vuln_index": {integer}, "severity_index": {integer}, "severity": {integer} } ], }根据上面获取任务信息中得到的主机id和任务id，我们可以实现这个功能def get_host_vulnerabilities(scan_id, host_id): header = { "X-ApiKeys": "accessKey={accesskey};secretKey={secretkey}".format(accesskey=accesskey, secretkey=secretkey), "Content-Type": "application/json", "Accept": "text/plain" } scan_history = ScanHistory.objects.get(id=scan_id) api = "https://{ip}:{port}/scans/{task_id}/hosts/{host_id}".format(ip=ip, port=port, task_id=scan_id, host_id=host_id) response = requests.get(api, headers=header, verify=False) if response.status_code != 200: return 2, "Data Error" data = json.loads(response.text) vulns = data["vulnerabilities"] for vuln in vulns: vuln_name = vuln["plugin_name"] plugin_id = vuln["plugin_id"] #插件id，可以获取更详细信息，包括插件自身信息和扫描到漏洞的解决方案等信息 #保存漏洞信息获取漏洞输出信息与漏洞知识库信息我们在nessus web页面中可以看到每条被检测到的漏洞在展示时会有输出信息和知识库信息，这些信息也可以根据接口来获取获取漏洞的知识库可以通过接口 GET /scans/{scan_id}/hosts/{host_id}/plugins/{plugin_id} , 它的路径为: https://localhost:8834/api#/resources/scans/plugin-output它返回的值如下:{ "info": { "plugindescription": { "severity": {integer}, //危险等级，从info到最后的critical依次为1，2，3，4，5 "pluginname": {string}, "pluginattributes": { "risk_information": { "risk_factor": {string} }, "plugin_name": {string}, //插件名称 "plugin_information": { "plugin_id": {integer}, "plugin_type": {string}, "plugin_family": {string}, "plugin_modification_date": {string} }, "solution": {string}, //漏洞解决方案 "fname": {string}, "synopsis": {string}, "description": {string} //漏洞描述 }, "pluginfamily": {string}, "pluginid": {integer} } }, "output": [ plugin_output:{ "plugin_output": {string}, //输出信息 "hosts": {string}, //主机信息 "severity": {integer}, "ports": {} //端口信息 } ] }有了这些信息，我们可以通过下面的代码获取这些信息:def get_vuln_detail(scan_id, host_id, plugin_id) header = { "X-ApiKeys": "accessKey={accesskey};secretKey={secretkey}".format(accesskey=accesskey, secretkey=secretkey), "Content-Type": "application/json", "Accept": "text/plain" } api = "https://{ip}:{port}/scans/{scan_id}/hosts/{host_id}/plugins/{plugin_id}".format(ip=ip, port=port, scan_id=scan_id, host_id=host_id, plugin_id=plugin_id) response = requests.get(api, headers=header, verify=False) data = json.loads(response.text) outputs = data["outputs"] return outputs最后总结这篇文章我们主要介绍了nessus API从扫描设置到扫描任务创建、启动、停止、以及结果的获取的内容，当然nessus的api不止这些，但是最重要的应该是这些，如果能帮助各位解决手头上的问题自然是极好的，如果不能或者说各位朋友需要更细致的控制，可以使用浏览器抓包的方式来分析它的请求和响应包。在摸索时最好的两个帮手是浏览器 F12工具栏中的 network和nessus api文档页面上的test工具了。我们可以先按 f12 打开工具并切换到network，然后在页面上执行相关操作，观察发包即可发现该如何使用这些API，因为Nessus Web端在操作时也是使用API。如下图:或者可以使用文档中的test工具，例如下面是测试 获取插件输出信息的接口

2019年终总结与2020年展望 时光荏苒，岁月如梭。转眼间2019已经过去，来到了新的一年，回顾这一年很多目标没有达成，有些遗憾，成长似乎比原来少了很多。下面来仔细回顾一下过去一年的得失2019 年回顾在2019 年年初立下的flag似乎没有一个能很好的执行的，博客，读书计划，学习方面，似乎总体来说仍然在原地踏步。博客方面，最开始想的是一周4篇，希望通过输出博客的方式来总结经验，提高自己。但是后续在执行时似乎变了味道，为了产出而产出。特别是在学习总结Java相关内容的时候。关于Java的文章我感觉是自己写的最烂的，从时间上说，过去为了产出一篇博客，会先列提纲、考虑文章的结构，会考虑如何组织语言让自己写的内容更好懂，甚至会精心准备实例代码，画图等等，但是在Java部分我省略了这些过程，博客书写时间从2个小时以上下降到半个小时，虽然说数量上去了，但是质量堪忧，与我之前想的总结提高完全背道而驰。这个问题今年得改。学习方面今年并没有什么大的成就，从4月份开始学习Java，到现在仍然有许多内容没有学完，基础部分进度很快，但是在框架中我会体会一下具体的设计模式，Web编程方面我学会了Web中编程中的基础操作，cookie、session一般如何使用、jsp模板思想，反射、工厂模式。我觉的学习它最大的用处不是学会了一门语言，而是让我开始思考如何从C语言的面向过程到面向对象的转化，让我接触到之前一直懵懵懂懂的web开发方面。如果有机会我可能会单独写写从面向过程到面向对象的转化思想关于读书方面，19年似乎读书量较去年又减少了许多。具体多少我没有统计可能不到10本，很多书都只能读一个开头，然后长时间不读，前面的忘记了再看后面的就无法串联起来，结果就放弃了。最后是工作方面的回顾，在这方面我感觉现在每年都是一个循环，年前一般是去年招的员工离职，自己工作的重心放在了维护扫描器产品上，年中开启一个新项目，然后招人，我带项目，项目一般持续两个月，没完没了的加班，然后修改，交付，过年，年后似乎又重复这个循环。每年招新人都需要我花时间来讲解公司流程，公司产品，甚至教一些编程语言与开发方面的东西，每年都是这样；自己感觉已经有点厌烦了。工作方面似乎没有任何进步，今年做漏洞管理平台方面的内容，针对漏洞信息做增删改查、明年又做一个什么平台，然后再针对不同数据做增删改查，一个项目下来似乎我只会了增删改查。做出来的平台都是一两个用户，当作单机软件使用，完全对不起项目名称中的平台。现在自己的处境虽然不在外包公司，但是我自己的感觉跟在外包公司类似。永远是针对不同信息的增删改查，似乎总有写不完的业务层代码。但是如果说自己所做的工作一无是处也不是这样的。今年的项目相比去年的项目来说，我参与的更多，对新人的要求也严格了许多，之前搭的gitlab服务终于启用起来了，并且尝试了单元测试。这些对我来说都是成长。在这次带领项目中，我学到了下面几点：有框架，有模板的，一定要用框架用模板。哪怕前期不动工。技术选型选的好会节约大量的时间。这次jQuery纯手写各种特效真的是给我热了很大的麻烦，如果早期选择一个好的模板，将节省大量调试前段的时间。敲定需求时要严谨，而且一旦定下来就不容更改。很多需求不是一拍脑袋想到就定下来的，必须得经过评审，是否可行，该如何去做，这些问题都得考虑，不然就得想我一样频繁改需求，导致所有人都得加班赶进度。我相信好的设计、好的产品应该做到让所有人节省工作时间，在单位时间内的产出更高2020年展望不管过的怎么样，总得面对现实，面对新来临的2020年，现在针对新的一年的展望如下：读书：这个是必须得坚持的，但是现在我觉得不应该硬性规定该读完多少本，我想的是现在应该坚持每天读半个小时书不再熬夜：这些年睡觉时间越来越晚，普遍超过12点才放下手机。现在在这里立下一个flag，11点以后放下手机，读半个小时书然后睡觉学习一门新的编程语言：在上面的部分也说过，学习Java最大的收获是完成了一个编程思维的转化，而之前读《黑客与画家》这本书时提到一个观点：编程语言的高度能决定一个人看问题的高度，之前一直不明白，现在似乎有点理解这个意思，而作者一直推崇lisp，所以明年的目标就是学习lisp，看看函数式编程语言能带给我怎样的收获开启一个新项目，之前吐槽了公司能学到的东西少，既然这样要么离开公司，要么自己想办法通过项目学习新内容。说实话我也很久没有自己独立做项目了，这里先立下一个flag，明年开启一个新项目，具体写什么东西还没有定目前能想到的就是这些，祝各位朋友心想事成，新年大吉吧

Mybatis框架 在之前的内容中，我写了Java的基础知识、Java Web的相关知识。有这些内容就可以编写各种各样丰富的程序。但是如果纯粹手写所有代码，工作量仍然很大。为了简化开发，隐藏一些不必要的细节，专心处理业务相关内容 ，Java提供了许多现成的框架可以使用Mybatis介绍在程序开发中讲究 MVC 的分层架构，其中M表示的是存储层，也就是与数据库交互的内容。一般来说使用jdbc时，需要经历：导入驱动、创建连接、创建statement对象，执行sql、获取结果集、封装对象、关闭连接这样几个过程。里面很多过程的代码都是固定的，唯一有变化的是执行sql并封装对象的操作。而封装对象时可以利用反射的机制，将返回字段的名称映射到Java实体类的各个属性上。这样我们很自然的就想到了，可以编写一个框架或者类库，实现仅配置sql语句和对应的映射关系，来实现查询到封装的一系列操作，从而简化后续的开发。Mybatis帮助我们实现了这个功能。Mybatis实例假设现在有一个用户表，存储用户的相关信息，我们现在需要使用mybatis来进行查询操作，可能要经历如下步骤：定义对应的实体类public class User { private Integer id; private String username; private String birthday; private char sex; private String address; //后面省略对应的getter和setter方法 //为了方便后面的实体类都会省略这些内容 } 编辑主配置文件，主要用来配置mybati的数据库连接信息以及指定对应dao的配置文件<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTDConfig3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <!--mybatis主配置文件--> <configuration> <!--配置环境--> <environments default="mybatis_demo"> <environment id="mybatis_demo"> <!--配置事务的类型--> <transactionManager type="JDBC"></transactionManager> <!--配置连接池--> <dataSource type="POOLED"> <!--配置数据库连接的4个基本信息--> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis_demo"/> <property name="username" value="root"/> <property name="password" value="masimaro_root"/> </dataSource> </environment> </environments> <!--指定配置文件的位置，配置文件是每个dao独立的配置文件--> <mappers> <mapper resource="com/MybatisDemo/Dao/IUserDao.xml"></mapper> </mappers> </configuration>编写dao接口public interface IUserDao { public List<User> findAll(); }并提供dao的xml配置文件<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTDMapper3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--每个函数配置一条，标签名是要进行的数据库操作，resultType是需要返回的数据类型--> <mapper namespace="com.MyBatisDemo.Dao.IUserDao"> <!--标签里面的文本是sql语句--> <select id="findAll" resultType="com.MyBatisDemo.domain.User"> select * from user; </select> </mapper>写完了对应的配置代码，接下来就是通过简单的几行代码来驱动mybatis，完成查询并封装的操作InputStream is = null; SqlSession = null; try { //加载配置文件 is = Resources.getResourceAsStream("dbconfig.xml"); //创建工厂对象 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder.build(is); //创建sqlsession对象 sqlSession = factory.openSession(); //使用sqlsession对象创建dao接口的代理对象 IUserDao userDao = sqlSession.getMapper(IUserDao.class); //使用对象执行方法 List<User> users = this.userDao.findAll(); System.out.println(users); } catch (IOException e) { e.printStackTrace(); }finally{ // 清理资源 if (null != this.is){ try { this.sqlSession.commit(); this.is.close(); } catch (IOException e) { e.printStackTrace(); } } if (null != this.sqlSession){ this.sqlSession.close(); } }mybatis大致的执行过程根据我们传入的InputStream对象来获取配置xml中对应对象的值接着根据配置信息创建连接并生成数据库的连接池对象根据配置文件中的mapper项获取到对应的Dao接口的配置文件，在读取该文件时会准备一个Map结构，其中key是mapper中的namespace + id，value是对应的sql语句，例如上述例子中得到的map结构为{"com.MyBatisDemo.Dao.IUserDao.findAll", "select * from user"}在创建sqlsession时从连接中获取到一个Statement对象在我们调用dao接口时，首先根据dao接口得到详细的类名，然后获取到当前调用的接口名称，由这两项得到一个key，比如在上述例子中，dao接口的名称为com.MyBatisDemo.Dao.IUserDao, 而调用的方法是 findAll,将这两个字符串进行拼接，得到一个key，根据这个key去map中查找对应的sql语句。并执行执行sql语句获取查询的结果集根据resultType中指定的对象进行封装并返回对应的实体类使用mybatis实现增删改查操作在之前的代码上可以看出，使用mybatis来实现功能时，只需要提供dao接口中的方法，并且将方法与对应的sql语句绑定。在提供增删改查的dao方法时如果涉及到需要传入参数的情况下该怎么办呢？下面以根据id查询内容为例：我们先在dao中提供这样一个方法：public User findById(int id);然后在dao的配置文件中编写sql语句<!--parameterType 表示传入的参数的类型--> <select id="findById" resultType="com.MyBatisDemo.domain.User" parameterType="int"> select * from user where id = #{id} </select>从上面的配置可以看到，mybatis中， 使用#{} 来表示输入参数，使用属性parameterType属性来表示输入参数的类型。一般如果使用Java内置对象是不需要使用全限定类名，也不区分大小写。当我们使用内置类型的时候，这里的id 仅仅起到占位符的作用，取任何名字都可以看完了使用内置对象的实例，再来看看使用使用自定义类类型的情况，这里我们使用update的例子来说明,首先与之前的操作一样，先定义一个upate的方法：void updateUser(User user);然后使用如下配置<update id="updateUser" parameterType="User"> update user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id = #{id} </update>与使用id查询的配置类似，当我们使用的是自定义类类型时，在对应的字段位置需要使用类的属性表示，在具体执行的时候，mybatis会根据传入的类对象来依据配置取出对应的属性作为sql语句的参数。上面在使用内置对象时我们说它可以取任何的名称，但是这里请注意 名称只能是自定义对象的属性名，而且区分大小写这里使用的都是确定的值，如果要使用模糊查询时该如何操作呢，这里我们按照名称来模糊查询,首先在dao中提供一个对应的方法User findByName(String name);接着再来进行配置<select resultType="com.MyBatisDemo.domain.User" parameterType="String"> select * from User where username like #{username} </select>从sql语句来看我们并没有实现模糊的方式，这时候在传入参数的时候就需要使用模糊的方式，调用时应该在参数中添加 %%, 就像这样 userDao.findByName("%" + username + "%")当然我们可以使用另外一种配置<select resultType="com.MyBatisDemo.domain.User" parameterType="String"> select * from User where username like %${username}% </select>这样我们在调用时就不需要额外添加 % 了。既然他们都可以作为参数，那么这两个符号有什么区别呢？区别在于他们进行查询的方式，$ 使用的是字符串拼接的方式来组成一个完成的sql语句进行查询，而#使用的是参数话查询的方式。一般来说拼接字符串容易造成sql注入的漏洞，为了安全一定要使用参数话查询的方式mybatis的相关标签resultMap标签在之前的配置中，其实一直保持着数据库表的字段名与对应的类属性名同名，但是有些时候我们不能保证二者同名，为了解决这问题也为了以后进行一对多和多对多的配置，可以使用resultMap来定义数据库表字段名和类属性名的映射关系下面是一个使用它的例子。我们简单修改一下User类的属性定义public class User { private Integer uid; private String name; private String userBirthday; private char userSex; private String userAddress; //后面省略对应的getter和setter方法 }这样直接使用之前的配置执行会报错，报找不到对应属性的错误，这个时候就可以使用resultMap属性来解决这个问题<resultMap id="UserMapper" type="User"> <id column="id" property="uid"></id> <result column="username" property="username"></result> <result column="sex" property="sex"></result> <result column="birthday" property="birthday"></result> <result column="address" property="address"></result> </resultMap> <select id="findAll" resultMap="UserMapper"> select * from user; </select>其中 id属性来唯一标示这个映射关系，在需要使用到这个映射关系的地方，使用resultMap这个属性来指定type属性表示要将这些值封装到哪个自定义的类类型中resultMap中有许多子标签用来表示这个映射关系id用来表明表结构中主键的映射关系result表示其他字段的映射关系每个标签中的column属性表示的是对应的表字段名标签中的property对应的是类属性的名称properties 标签properties标签可以用来定义数据库的连接属性，主要用于引入外部数据库连接属性的文件，这样我们可以通过直接修改连接属性文件而不用修改具体的xml配置文件。假设现在在工程中还有一个database.properties文件jdbc.driver ="com.mysql.jdbc.Driver" jdbc.url = "jdbc:mysql://localhost:3306/mybatis_demo" jdbc.username ="root" jdbc.password" ="masimaro_root"然后修改对应的主配置文件<!--引入properties文件--> <properties resource="database.properties"> </properties> <!--修改对应的dataSource标签--> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </dataSource>typeAliases 标签之前我们说过，使用内置类型时不需要写全限定类名，而且它不区分大小写。而使用自定义类型时需要写很长一串，如何使自定义类型与内置类型一样呢？这里可以使用typeAliases标签。它用来定义类名的别名<typeAliases> <!--typeAlias中来定义具体类的别名，type表示真实类名，alias表示别名--> <typeAlias type="com.MyBatisDemo.domain.User" alias="user"></typeAlias> </typeAliases>使用typeAlias标签时，每个类都需要提供一条对应的配置，当实体类多了，写起来就很麻烦了，这个时候可以使用package子标签来代替typeAlias<typeAliases> <package name="com.MyBatisDemo.domain"/> </typeAliases>它表示这里包中的所有类都使用别名，别名就是它的类名package标签在定义对应的mapper xml文件时，一个dao接口就需要一条配置。dao接口多了，一条条的写很麻烦，为了减轻编写的工作量可以使用package标签<mappers> <!--它表示这个包中的所有xml都是mapper配置文件--> <package name="com/MyBatis/Dao"/> </mappers>连接池在配置数据库连接 dataSource 标签中有一个type属性，它用来定义使用的连接池，该属性有三个取值：POOLE：使用连接池，采用javax.sql.DataSource 规范中的连接池，mybatis中有针对它的数据库连接池的实现UNPOOLED：与POOLED相同，使用的都是javax.sql.DataSource 规范，但是它使用的是常规的连接方式，没有采用池的思想JNDI：根据服务器提供的jndi基础来获取数据库的连接 ，具体获取到的连接对象又服务器提供动态sql当我们自己拼接sql的时候可以根据传入的参数的不同来动态生成不同的sql语句执行，而在之前的配置中，我们事先已经写好了使用的sql语句，但是如果碰上使用需要按照条件搜索，而且又不确定用户会输入哪些查询条件，在这样的情况下，没办法预先知道该怎么写sql语句。这种情况下可以使用mybatis中提供的动态sql假设我们提供一个findByValue的方法，根据值来进行查询。public List<User> findByValue(User user);事先并不知道user的哪些属性会被赋值，我们需要做的就是判断user的哪些属性不为空，根据这些不为空的属性来进行and的联合查询。这种情况下我们可以使用if标签<select id="findByValue" resultType="User" parameterType="User"> select * from user where <if test="id != null"> id = #{id} and </if> <if test="username != null"> username=#{username} and </if> ..... 1=1 </select>if标签中使用test来进行条件判断，而判断条件可以完全使用Java的语法来进行。这里在最后用了一个1=1的条件来结束判断，因为事先并不知道用户会传入哪些值，不知道哪条语句是最后一个条件，因此我们加一个恒成立的条件来确保sql语句的完整当然mybatis中也有办法可以省略最后的1=1，我们可以使用 where标签来包裹这些if，表明if中的所有内容都是作为查询条件的，这样mybatis在最后会在生成查询条件后自动帮助我们进行格式的整理使用if标签我们搞定了不确定用户会使用哪些查询条件的问题，如果有这样一个场景：用户只知道某个字段的名字有几种可能，我们在用户输入的几种可能值中进行查找，也就是说，用户可以针对同一个查询条件输入多个可能的值，根据这些个可能的值进行匹配，只要有一个值匹配上即可返回；针对这种情况没办法使用if标签了，我们可以使用循环标签，将用户输入的多个值依次迭代，最终组成一个in的查询条件我们在这里提供一个根据多个id查找用户的方法public List<User> findByIds(List<Integer> ids);这里我们为了方便操作，额外提供一个类用来存储查询条件public class QueryVo { List<Integer> ids; }<select id="findUserByIds" resultType="User" parameterType="QueryVo"> select * from user <where> <if test="ids != null and ids.size() != 0"> <foreach collection="ids" open="and id in (" close=")" item= "id" separator=","> ${id} </foreach> </if> </where> </select>在上面的例子中使用foreach来迭代容器其中使用collection表示容器，这里取的是parameterType中指定类的属性，open表示在迭代开始时需要加入查询条件的sql语句，close表示在迭代结束后需要添加到查询语句中的sql，item表示每个元素的变量名，separator表示每次迭代结束后要添加到查询语句中的字符串。当我们迭代完成后，整个sql语句就变成了这样: select * from user where 1=1 and id in (id1, id2, ...)多表查询一对多查询在现实中存在着这么一些一对多的对应关系，像什么学生和班级的对应关系，用户和账户的对应关系等等。关系型数据库在处理这种一对多的情况下，使用的是在多对应的那张表中添加一个外键，这个外键就是对应的一那张表的主键，比如说在处理用户和账户关系时，假设一个用户可以创建多个账户，那么在账户表中会有一个外键，指向的是用户表的ID在上面例子的基础之上，来实现一个一对多的关系。首先添加一个账户的实体类，并且根据关系账户中应该有一个唯一的用户类对象，用来表示它所属的用户public class Account { private int id; private int uid; private double money; private User user; }同时需要在User这个实体类上添加一个Account的列表对象，表示一个User下的多个Accountpublic class User { private Integer id; private String username; private String birthday; private char sex; private String address; private List<Account> accounts; }首先根据user来查询多个account，我们可以写出这样的sql语句来查询select u.*, a.id as aid, a.money, a.uid from user as u left join account as a on a.uid = u.id;那么它查询出来的结果字段名称应该是id, username, sex, birthday, address, aid, money, uid 这些，前面的部分可以封装为一个User对象，但是后面的部分怎么封装到Accounts中去呢，这里可以在resultMap中使用collection标签，该标签中对应的对象会被封装为一个容器。因此这里的配置可以写为：<resultMap id="UserAccountMap" type="user"> <id property="id" column="id"></id> <result property="username" column="username"></result> <result property="birthday" column="birthday"></result> <result property="sex" column="sex"></result> <result property="address" column="address"></result> <collection property="accounts" ofType="account"> <id property="id" column="aid"></id> <result property="money" column="money"></result> <result property="uid" column="uid"></result> </collection> </resultMap> <select id="findAll" resultMap="UserAccountMap"> select u.*, a.ID as aid, a.MONEY, a.UID from user as u left join acc ount as a on u.id = a.uid </select>我们需要一个resultMap来告诉Mybatis，这些多余的字段该怎么进行封装，为了表示一个容器，我们使用了一个coolection标签，标签中的property属性表示这个容器被封装到resultType对应类的哪个属性中，ofType表示的是，容器中每一个对象都是何种类型，而它里面的子标签的含义与resultMap子标签的含义完全相同从User到Account是一个多对多的关心，而从Account到User则是一个一对一的关系，当我们反过来进行查询时，需要使用的配置是 association 标签，它的配置与使用与collection相同<resultMap id="AccountUserMap" type="Account"> <id property="id" column="aid"></id> <result property="uid" column="uid"></result> <result property="money" column="money"></result> <association property="user" column="uid" javaType="user"> <id property="id" column="uid"></id> <result property="username" column="username"></result> <result property="birthday" column="birthday"></result> <result property="sex" column="sex"></result> <result property="address" column="address"></result> </association> </resultMap> <select id="findUserAccounts" resultType="Account" parameterType="User"> select * from account where uid = ${id} </select>多对多查询说完了一对多，再来说说多对多查询。多对多在关系型数据库中使用第三张表来体现，第三张表中记录另外两个表的主键作为它的外键。这里使用用户和角色的关系来演示多对多查询与之前一样，在两个实体类中新增对方的一个list对象，表示多对多的关系public class Role implements Serializable { private int id; private String roleName; private String roleDesc; private List<User> users; }利用之前一对多的配置，我们只需要修改一下ResultMap和sql语句就可以完成多对多的查询<mapper namespace="com.liuhao.Dao.IUserDao"> <resultMap id="UserRoleMapper" type="User"> <id property="id" column="id"></id> <result column="username" property="username"></result> <result column="sex" property="sex"></result> <result column="address" property="address"></result> <result column="birthday" property="birthday"></result> <collection property="roles" ofType="role"> <id property="id" column="rid"></id> <result column="role_desc" property="roleDesc"></result> <result column="role_name" property="roleName"></result> </collection> </resultMap> <select id="findAll" resultMap="UserRoleMapper"> select user.*, role.ID as rid, role.ROLE_DESC, role.ROLE_NAME from u ser left outer join user_role on user_role.uid = user.id left OUTER join role on user_role.RID = role.ID </select> </mapper>另一个多对多的关系与这个类似，这里就不再单独说明了延迟加载之前说了该如何做基本的单表和多表查询。这里有一个问题，在多表查询中，我们是否有必要一次查询出它所关联的所有数据，就像之前的一对多的关系中，在查询用户时是否需要查询对应的账户，以及查询账户时是否需要查询它所对应的用户。如果不需要的话，我么采用上面的写法会造成多执行一次查询，而且当它关联的数据过多，而这些数据我们用不到，这个时候就会造成内存资源的浪费。这个时候我们需要考虑使用延迟加载，只有需要才进行查询。之前的sql语句一次会同时查询两张表，当然不满足延迟加载的要求，延迟加载应该将两张表的查询分开，先只查询需要的一张表数据，另一张表数据只在需要的时候查询。根据这点我们进行拆分,假设我们要针对User做延迟加载，我们先不管accounts的数据，只查询user表，可以使用sql语句select * from user, 在需要的时候执行select * from account where uid = id在xml配置中可以在collection标签中使用select属性，该属性指向一个方法，该方法的功能是根据id获取所有对象的列表。也就说我们需要在AccountDao接口中提供这么一个方法,并且编写它的xml配置public List<Account> findByUid(int uid);接着我们对之前的xml进行改写<resultMap id="UserMapper" type="User"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="sex" property="sex"></result> <result column="birthday" property="birthday"></result> <result column="address" property="address"></result> <collection property="accounts" ofType="Account" select="com.liuhao.Dao.IAccountDao.findByUid" column="id"> </collection> </resultMap> <select id="findAll" resultMap="UserMapper"> select * from user; </select>完成了接口的编写与配置，还需要对主配置文件做一些配置，我们在主配置文件中添加settings节点，开启延迟加载<settings> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"/> </settings>缓存缓存用来存储一些不经常变化的内容，使用缓存可以减少查询数据库的次数，提高效率。mybatis有两种缓存，一种是在每个sqlsession中的缓存，一种是在每个SqlSessionFactory中的缓存在SqlSession中的缓存又被叫做是Mybatis的一级缓存。每当完成一次查询操作时，会在SqlSession中形成一个map结构，用来保存调用了哪个方法，以及方法返回的结果，下一次调用同样的方法时会优先从缓存中取当我们执行insert、update、delete等sql操作，或者执行SqlSession的close或者clearCache等方法时缓存会被清理在SqlSessionFactory中的缓存被称做二级缓存，所有由同一个SqlSessionFactory创建出来的SqlSessin共享同一个二级缓存。二级缓存是一个结果的二进制值，每当我们使用它时，它会取出这个二进制值，并将这个值封装为一个新的对象。在我们多次使用同一片二级缓存中的数据，得到的对象也不是同一个使用二级缓存需要进行一些额外的配置：在主配置文件中添加配置 在settings的子标签setting 中添加属性 enableCache=True开启二级缓存在对应的dao xml配置中添加 cache标签（标签中不需要任何属性或者文本内容）,使接口支持缓存在对应的select、update等标签上添加属性 useCache=true，为方法开启二级缓存

EL表达式与JSTL JSP标准标签库（JSTL）是一个JSP标签集合，它封装了JSP应用的通用核心功能。JSTL支持通用的、结构化的任务，比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。 除了这些，它还提供了一个框架来使用集成JSTL的自定义标签。JSTL安装要使用jstl需要导入对应的库，可以去官方站点下载, 点击这里下载然后解压文件将得到的jar包放入到WEB-INF的lib中导入之后，在要使用它的jsp文件中使用taglib 导入库<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>prefix 是标签的前缀，类似于命名空间，在使用库中的标签时需要加上这个前缀常用标签if 标签if标签用来做判断，当条件成立时，执行标签体的内容，条件写在test属性中，注意：只有if标签而没有对应的else标签。下面是一个例子:<c:if test="${not empty requestScope.error}"> <div style="color:red;width:100%;" align = "center">${requestScope.error}</div> </c:if>上述这个例子表示，当服务器返回错误信息时，将错误信息显示到页面上choose 标签choose 标签相当于switch 语句，该标签中可以包含 when 和 otherwise 作为字标签，相当于switch语句中的case和default，例如下面的例子<p>当前薪水为 : <c:out value="${salary}"/></p> <c:choose> <c:when test="${salary <= 2000}"> 老板我是你爹, 这个工作谁爱干谁干 </c:when> <c:when test="${salary > 50000}"> 公司是我家，工作就是我的价值，我热爱工作 </c:when> <c:otherwise> 心中无半点波澜，甚至想提前下班 </c:otherwise> </c:choose>foreach 标签foreach 用来迭代容器中的元素，或者完成一些重复的操作。当使用foreach标签来进行重复性的操作时可以使用begin、end、var来控制循环，begin表示循环变量开始的值，end表示循环变量结束的值，与正常的for循环不同，循环变量的值可以等于end的值；使用var标签来定义循环变量的名称，使用step表示步进。例如:<c:foreach begin = "1" end = "10" var = "i step = "1"> ${i} <br /> </c:foreach>等价于for(int i = 1; i <= 10; i++){ System.out.println(i); }当使用 foreach来迭代容器时使用item和 var来迭代，其中item为需要迭代的容器，var表示获取到的容器中的元素。例如<c:foreach items = "list" var = "l"> ${l} </c:foreach>等价于for(String l:list){ System.out.println(l); }ELEL 表达式：Expression Language 表达式语言，用于替换和简化jsp页面中java代码的编写。EL 表达式使用 ${} 来表示jsp 默认支持el表达式，在page指令中可以使用 isELIgnored 来指定是否忽略jsp页面中的el表达式；当然也可以使用 \ 来作为转义符，表示 这个el表达式原样输出，例如 \${cookie}EL表达式中可以支持算数运算符、比较运算符、逻辑运算符合empty 空运算符；empty用于判断字符串、集合、数组对象是否为null或者长度为0。在使用el表达式时需要注意以下几点：el表达式只能从域对象中获取值el表达式中如果是类对象，可以根据Java Bean规范来获取属性值针对list这种有序集合可以使用 ${域对象.键名[索引].属性}针对Map集合,使用 ${域对象.键名.key名}或者 ${域对象.键名["key名"]}el 表达式中对域对象都做了重命名，pageScope 对应于 pageContext、requestScope对应于request、sessionScope对应于session、applicationScope对应于applicate(ServletContext)表达式${键名} 依次从最小的域中去查找对应的键值，直到找到为止