();
44 | (3) 如果没有合适的接口存在，完全可以用类而不是接口来引用对象。
45 |
46 | 53.接口优先于反射机制。
47 | (1) 核心反射机制(core reflection facility) java.lang.reflect, 提供了"通过程序来访问关于已装载的类的信息"
48 | 的能力。
49 | 代价：① 丧失了编译时类型检查的好处；
50 | ② 执行反射机制访问所需要的代码非常笨拙和冗长；
51 | ③ 性能损失。
52 | (2) 可以以反射方式创建实例，然后通过它们的接口或者超类，以正常的方式访问这些实例。
53 |
54 | 54.谨慎地使用本地方法。
55 | Java Native Interface (JNI) 允许 Java 应用程序可以调用本地方法(native method)。
56 | ① 访问特定平台的机制(如访问注册表和文件锁)；
57 | ② 访问遗留代码库的能力；
58 | ③ 编写应用程序中注重性能的部分。
59 |
60 | 55.谨慎地进行优化。
61 | (1) 努力避免那些限制性能的设计决策。
62 | (2) 要考虑 API 设计决策的性能后果。
63 |
64 | 56.遵守普遍接受的命名惯例。
65 |
66 | 57.只针对异常的情况才使用异常。
67 |
68 | 58.对可恢复的情况使用受检异常，对编程错误使用运行时异常。
69 |
70 | 59.避免不必要地使用受检的异常。
71 |
72 | 60.优先使用标准的异常。
73 | IllegalArgumentException：非 null 的参数值不正确；
74 | IllegalStateException：对于方法调用而言，对象状态不合适；
75 | NullPointerException：在禁止使用 null 的情况下参数为 null；
76 | IndexOutOfBoundsException：下标参数值越界；
77 | ConcurrentModificationException：在禁止并发修改的情况下，检测到对象的并发修改；
78 | UnsupportedOperationException：对象不支持用户请求的方法。
79 | ```
80 |
--------------------------------------------------------------------------------
/Learning-Notes/Tools.md:
--------------------------------------------------------------------------------
1 | C.编程工具软件
2 |
3 |
49 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringFramework/SpringFramework.md:
--------------------------------------------------------------------------------
1 | 《Spring 2.5开发手册》 :books:
2 |
3 | > Spring Cloud 中文文档
4 |
5 | * IoC(控制反转)容器 (1-4条)
6 | * IoC(控制反转)容器 (5-8条)
7 | * 资源 (9-13条)
8 | * 校验、数据绑定、BeanWrapper 与属性编辑器 (14-15条)
9 | * 使用 Spring 进行面向切面编程(AOP) (16-24条)
10 | * Spring AOP APIs (25-30条)
11 | * Spring AOP APIs (31-37条)
12 | * 测试 (38-42条)
13 | * 事务管理 (43-47条)
14 | * 使用 JDBC 进行数据访问 (48-50条)
15 | * 使用 JDBC 进行数据访问 (51-53条)
16 | * 使用 ORM 工具进行数据访问 (54-58条)
17 | * Web MVC framework Web 框架(59-69条)
18 | * 集成视图技术(70-73条)
19 | * 集成其它 Web 框架(74-76条)
20 | * 使用 Spring 进行远程访问与 Web 服务(77-82条)
21 | * JMS、JMX、JCA CCI(83-95条)
22 | * Spring 邮件抽象层、定时调度 (Scheduling) 和线程池 (Thread Pooling)(96-101条)
23 |
--------------------------------------------------------------------------------
/Learning-Notes/Experiences.md:
--------------------------------------------------------------------------------
1 | R.心得杂谈
2 |
3 |
55 |
--------------------------------------------------------------------------------
/Reading-Notes/TechnologyArchitecture.md:
--------------------------------------------------------------------------------
1 | 《大型网站技术架构-核心原理与案例分析》 :books:
2 |
3 | > 李智慧 著 电子工业出版社
4 |
5 | ```txt
6 | 1.大型网站架构演化发展历程：
7 | (1) 初始阶段的网站架构;
8 | (2) 应用服务和数据服务分离;
9 | (3) 使用缓存改善网站性能;
10 | (4) 使用应用服务器集群改善网站的并发处理能力;
11 | (5) 数据库读写分离;
12 | (6) 使用反向代理和 CDN 加速网站响应;
13 | (7) 使用分布式文件系统和分布式数据库系统;
14 | (8) 使用 NoSQL 和搜索引擎;
15 | (9) 业务拆分;
16 | (10) 分布式服务。
17 |
18 | 2.网站架构模式：分层、分割、分布式、集群、缓存、异步、冗余、自动化、安全。
19 |
20 | 3.大型网站核心架构要素：性能、可用性、伸缩性、扩展性、安全性。
21 |
22 | 4.高可用网站的软件质量保证：网站发布、自动化测试、预发布验证、代码控制、自动化发布、灰度发布。
23 |
24 | 5.应用服务器集群的伸缩性设计：
25 | (1) HTTP 重定向负载均衡;
26 | (2) DNS 域名解析负载均衡;
27 | (3) 反向代理负载均衡;
28 | (4) IP 负载均衡;
29 | (5) 数据链路层负载均衡;
30 | (6) 负载均衡算法。
31 |
32 | 6.网站性能优化：
33 | 1)Web前端性能优化
34 | (1) 浏览器访问优化：
35 | -减少 http 请求.
36 | -使用浏览器缓存.
37 | -启用压缩.
38 | -CSS放在页面最上面, JavaScript放在页面最下面.
39 | -减少Cookie传输.
40 | (2) CDN(内容分发网络)加速：缓存静态资源.
41 | (3) 反向代理：安全功能，配置缓存加速Web请求，负载均衡.
42 | 2)应用服务器性能优化：
43 | (1) 分布式缓存.
44 | -网站性能优化第一定律：优先考虑使用缓存优化性能.
45 | -合理使用缓存：缓存预热，缓存穿透.
46 | -分布式缓存架构：
47 | a.以 JBoss Cache 为代表的需要更新同步的分布式缓存；
48 | b.以 Memcached 为代表的不互相通信的分布式缓存.
49 | (2) 异步操作：使用消息队列将调用异步化，削峰作用.
50 | (3) 使用集群.
51 | (4) 代码优化.
52 | -多线程：启动线程数＝[任务执行时间 / (任务执行时间 - IO 等待时间)] × CPU 内核数.
53 | a.将对象设计成无状态对象；
54 | b.使用局部对象；
55 | c.并发访问资源时使用锁.
56 | -资源复用：单例( Singleton ) 和对象池(Object Pool).
57 | -数据结构：字符串 Hash 散列算法 Time33 算法，即对字符串逐字符迭代乘以33，求得 Hash 值：
58 | hash(i) = hash(i-1) * 33 + str[i]
59 | 原始字符串 (MD5) → 信息指纹 (hash) → HashCode.
60 | -垃圾回收.
61 | 3)存储性能优化：
62 | (1) 机械硬盘 vs 固态硬盘(SSD).
63 | (2) B+ 树 vs LSM 树.
64 | 关系型数据库多采用两级索引的B+树.
65 | B+ 树是一种专门针对磁盘存储而优化的N叉排序树，以树节点为单位存储在磁盘中，
66 | 从根开始查找所需数据所在的节点编号和磁盘位置，将其加载到内存中然后继续查找，直到找到所需的数据.
67 | NoSQL产品多采用 LSM 树作为主要数据结构.
68 | LSM 树可以看作是一个N阶合并树. 数据写操作(包括插入、修改、删除)都在内存中进行，并且会创建一个新纪录
69 | (修改会记录新的数据值，而删除会记录一个删除标志)，这些数据在内存中仍然还是一棵排序树，当数据量超过设定的
70 | 内存阈值后，会将这棵排序树和磁盘上最新的排序树合并。
71 | (3) RAID(廉价磁盘冗余阵列) vs HDFS(Hadoop 分布式文件系统)
72 | HDFS 两类重要的服务器角色：NameNode (名字服务节点)和 DataNode (数据存储节点).
73 | HDFS 配合 MapReduce 等并行计算框架进行大数据处理时，可以在整个集群上并发读写访问所有的磁盘，无需 RAID 支持.
74 |
75 | 7.网站应用攻击与防御：
76 | 1) XSS 攻击：即跨站点脚本攻击(Cross Site Script)，指黑客通过篡改网页，注入恶意 HTML 脚本，在用户浏览网页时，
77 | 控制用户浏览器进行恶意操作的一种攻击方式.
78 | 常见的 XSS 攻击类型有两种：一种是反射型，另一种是持久型.
79 | 防范 XSS 攻击的手段：过滤和消毒(如">"转义为"＆gt")、HttpOnly(Cookie).
80 | 2) 注入攻击：主要有两种形式，SQL 注入攻击和 OS 注入攻击.
81 | 防范注入攻击的手段：请求参数消毒(过滤请求数据中的SQL，如"drop table"，
82 | "\b(?:update\b.*?\bset|delete\b\W*?\bfrom)\b"等)、参数绑定.
83 | 3) CSRF 攻击：(Cross Site Request Forgery)跨站点请求伪造，攻击者通过跨站请求，以合法用户的身份进行非法操作，
84 | 如转账交易、发表评论等.
85 | 防范 CSRF 攻击的手段主要是识别请求者身份：表单Token、验证码、Referer check.
86 | 4) 其他攻击和漏洞：Error Code、HTML注释、文件上传、路径遍历.
87 | 5) Web 应用防火墙：ModSecurity是一个开源的 Web 应用防火墙，探测攻击并保护 Web 应用程序，它采用处理逻辑与攻击规则
88 | 集合分离的架构模式.
89 | 6) 网站安全漏洞扫描.
90 | ```
91 |
--------------------------------------------------------------------------------
/Learning-Notes/MobileDevelopment.md:
--------------------------------------------------------------------------------
1 | I.移动开发
2 |
3 | 移动开发周刊：http://mobilev5.github.io/
4 |
41 |
42 |
59 |
--------------------------------------------------------------------------------
/CNBlogs-SourceCode/footer.html:
--------------------------------------------------------------------------------
1 |
2 |
41 |
42 |
46 |
47 |
106 |
107 |
--------------------------------------------------------------------------------
/Reading-Notes/MoreEffectiveCPlusPlus/MoreEffectiveCPlusPlus2.md:
--------------------------------------------------------------------------------
1 | 《More Effective C++》 :books:
2 |
3 | > [美] Scott Meyers 著 电子工业出版社
4 |
5 | ```c++
6 | 11.禁止异常 (exception) 流出 destructors 之外。
7 | (1) 可以避免 terminate 函数在 exception 传播过程的栈展开 (stack-unwinding) 机制中被调用。
8 | (2) 可以协助确保 destructors 完成其应该完成的所有事情。
9 | Session::~Session() {
10 | try {
11 | logDestruction(this);
12 | } catch (...) { }
13 | }
14 |
15 | 12.了解 “抛出一个 exception” 与 “传递一个参数” 或 “调用一个虚函数” 之间的差异。
16 | “传递对象到函数去，或是以对象调用虚函数” 和 “将对象抛出成为一个 exception” 之间，有 3 个主要差异：
17 | (1) exception objects 总是会被复制，如果以 by value 方式捕捉，它们甚至被复制两次。至于传递给函数参数的
18 | 对象则不一定得复制。
19 | (2) “被抛出成为 exceptions” 的对象，其被允许的类型转换动作，比 “被传递到函数去” 的对象少。
20 | (3) catch 子句以其 “出现于源代码的顺序” 被编译器检验比对，其中第一个匹配成功者便执行；而当我们以某对象调用
21 | 一个虚函数，被选中执行的是那个 “与对象类型最佳吻合” 的函数，不论它是不是源代码所列的第一个。
22 | ```
23 | 
24 |
25 | ```c++
26 | 13.以 by reference 方式捕捉 exceptions。
27 | void doSomething() {
28 | try {
29 | someFunction();
30 | } catch (exception& ex) {
31 | cerr << ex.what(); // 调用 Validation_error::what() 而非 exception::what()
32 | ...
33 | }
34 | }
35 |
36 | 14.明智运用 exception specifications。
37 | 所有非预期的 exceptions 都以 UnexpectedException objects 取而代之。
38 | class UnexpectedException {};
39 | void convertUnexpected() { // 如果有一个非预期的 exception 被抛出，便调用此函数
40 | throw UnexpectedException();
41 | }
42 | set_unexpected(convertUnexpected); // convertUnexpected 取代默认的 unexpected 函数
43 |
44 | 15.了解异常处理 (exception handling) 的成本。
45 | 使用 try 语句块，代码大约整体膨胀 5% ~ 10%，执行速度亦大约下降这个数。
46 |
47 | 16.谨记 80 - 20 法则。
48 | 80 - 20 法则：一个程序 80% 的资源用于 20% 的代码身上。
49 |
50 | 17.考虑使用 lazy evaluation (缓式评估)。
51 | lazy evaluation 在许多领域中都可能有用途：可避免非必要的对象复制，可区别 operator[] 的读取和写动作，
52 | 可避免非必要的数据库读取动作，可避免非必要的数值计算动作。
53 |
54 | 18.分期摊还预期的计算成本。
55 | 可以通过超急评估 (over-eager evaluation) 如缓存 (caching) 和 预先取出 (prefetching)
56 | 等做法分期摊还预期运算成本。
57 | int findCubicleNumber(const string& employeeName) {
58 | // 定义一个 static map 以持有 (employee name, cubicle number) 数据对。这个 map 用来做局部缓存
59 | typedef map CubicleMap;
60 | static CubicleMap cubes;
61 | // 尝试在 cache 中针对 employeeName 找出一笔记录。如果确有一笔， 迭代器便会指向该笔找到的记录
62 | CubicleMap::iterator it = cubes.find(employeeName);
63 | // 如果找不到任何吻合记录，迭代器的值将会是 cubes.end()。如果这样，则查询数据库，然后把它加进 cache 中
64 | if (it == cubes.end()) {
65 | int cubicle = the result of looking up employeeName`s cubicle number int the database;
66 | cubes[employeeName] = cubicle;
67 | return cubicle;
68 | } else {
69 | // 迭代器指向正确的 cache 记录，只需获取 (employee name, cubicle number) pair 的第二项数据
70 | return (*it).second;
71 | }
72 | }
73 |
74 | 19.了解临时对象的来源。
75 | 任何时候只要你看到一个 reference-to-const 参数，就极可能会有一个临时对象被产生出来绑定至该参数上。
76 | 任何时候只要你看到函数返回一个对象，就会产生临时对象(并于稍后销毁)。
77 |
78 | 20.协助完成 “返回值优化(RVO)”。
79 | // 函数返回一个对象：最有效率的做法
80 | inline const Rational operator*(const Rational& lhs, const Rational& rhs) {
81 | return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
82 | }
83 | ```
84 |
--------------------------------------------------------------------------------
/Reading-Notes/InterviewExperience/AndroidInterview.md:
--------------------------------------------------------------------------------
1 | 华超的安卓(Android)面经 :memo:
2 |
3 | > 华超，根据整理。
4 |
5 | ```html
6 | 1.基础知识
7 | 1) Java基础
8 | ArrayList、LinkedList、Vector区别.
9 | BlockingQueue与CountDownLatch.
10 | Collections与Arrays.
11 | Exception与Error包结构，OOM，SOF你遇到哪些情况？
12 | HashCode作用.
13 | Java 1.7和Java 1.8新特性.
14 | Java NIO.
15 | Java基本数据类型及其相关操作.
16 | Java的四种引用，强弱软虚，用到的场景.
17 | Map、Set、List、Queue、Stack的特点与用法.
18 | Map相关子类区别.
19 | Object公有方法以及wait和sleep区别.
20 | Override与Overload区别.
21 | String相关内容学习.
22 | foreach与for循环效率对比.
23 | interface与abstract类的区别.
24 | static关键字.
25 | synchronized、lock、reentrantLock区别.
26 | 不同情形下return和finally的执行顺序.
27 | 关键字：transient、volatile.
28 | 反射原理及应用.
29 | 泛型特点及其类型转换.
30 | 生产者消费者问题的五种实现.
31 | 线程以及ThreadLocal.
32 | 线程池的使用.
33 | 解析XML的DOM与SAX以及PULL区别.
34 | 锁的等级：方法锁、对象锁、类锁.
35 | 面向对象的的特征和含义及多态实现原理.
36 |
37 | 2) Android基础
38 | 在AndroidStudio中自定义Gradle插件.
39 | Activity与Fragment的生命周期.
40 | Activity卡顿原因.
41 | Activity启动过程.
42 | Activity四种启动模式与IntentFilter匹配规则.
43 | Activtiy的状态保存.
44 | Android 7.0、6.0、5.0新特性.
45 | Android内存优化方法.
46 | Android动画.
47 | Android文件缓存方法.
48 | Android长连接，怎么处理心跳机制.
49 | Asset与res/raw,res/drawable.
50 | AsyncTask原理与使用.
51 | Bitmap相关.
52 | ContentProvider用法.
53 | IntentService.
54 | Json相比XML优劣势.
55 | Looper、Handler、MessageQueue.
56 | Merge与ViewStub布局标签.
57 | OkHttp.
58 | Service相关.
59 | Sqlite的基本操作.
60 | UIL原理解析.
61 | Volley原理解析.
62 | Zygote进程启动过程.
63 | 启动Activity的几种方式.
64 | 如何保证Service不被Kill.
65 | 如何加速启动Activity.
66 | 怎样退出终止App.
67 | 插件化原理（以DL框架为例）.
68 | 注册广播的两种方式.
69 | 热补丁技术概括.
70 | 自定义View.
71 | 通过自定义Gradle插件修改编译后的class文件.
72 |
73 | 3) 数据结构
74 | 各种排序算法复杂度对比.
75 | 排序算法.
76 | 数据结构基本概念及复杂度分析.
77 |
78 | 4) 操作系统
79 | IPC几种通信方式.
80 | 什么是虚拟内存.
81 | 死锁的必要条件，怎么处理死锁.
82 | 段存储，页存储，段页存储.
83 | 虚拟地址、逻辑地址、线性地址、物理地址的区别.
84 | 进程与线程.
85 | 银行家算法.
86 |
87 | 5) 计算机网络
88 | 3次握手和4次挥手过程.
89 | HTTP响应报文格式及各种响应码.
90 | HTTP请求报文格式.
91 | Http1.1和Http1.0的区别.
92 | Http怎么处理长连接.
93 | IP地址分类.
94 | OSI与TCP/IP各层的结构与功能.
95 | Ping的整个过程. ICMP报文是什么?
96 | TCP与UDP区别及其各自优缺点.
97 | TCP和UDP数据报格式.
98 | TCP拥塞控制和流量控制.
99 | http与https区别.
100 | 打开一个网页，整个过程使用到哪些协议.
101 | 滑动窗口与回退N针协议.
102 | 路由器与交换机区别.
103 |
104 | 6) 数据库
105 | 关系数据库基本概念.
106 | 关系模式的规范化.
107 | 函数依赖与候选码的定义.
108 | 数据库中数据查询.
109 | 数据库查询优化.
110 | 数据的添加、删除、修改.
111 | 表的创建、修改表结构、删除表.
112 |
113 | 7) JVM
114 | CAS是什么？
115 | GC收集器有哪些？
116 | GC的三种收集方法.
117 | 内存模型以及分区.
118 | 判断一个对象是否存活.
119 | 双亲委派模型.
120 | 对象的创建、内存布局、对象的访问定位.
121 | 新生代老年代内存划分比例及其各自特点.
122 | 类加载的五个过程.
123 | 静态分派和动态分派.
124 |
125 | 2.书籍推荐
126 | 任玉刚的《Android开发艺术探索》
127 | 周志明的《深入理解java虚拟机》
128 | 何红辉与关爱明的《Android源码设计模式解析与实战》
129 | 考研用的辅导书，当初用的是王道论坛编写的《数据结构》、《操作系统》、《计算机网络》
130 | 武汉大学的《数据库原理与技术》.
131 | 左程云的《程序员代码面试指南》
132 | 《剑指offer》
133 | 《Java编程思想》（作为“字典”查看）
134 | ```
135 |
--------------------------------------------------------------------------------
/Learning-Notes/SourceCode.md:
--------------------------------------------------------------------------------
1 | B.开源源码
2 |
3 |
61 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringFramework/SpringFramework14.md:
--------------------------------------------------------------------------------
1 | 《Spring 2.5开发手册》 :books:
2 |
3 | ```java
4 | 70.JSP 和 JSTL。
5 | 视图解析器: 使用 JSP 方式需要一个用来解析视图的视图解析器，常用的是在 WebApplicationContext 中定义的
6 | InternalResourceViewResolver 和 ResourceBundleViewResolver。
7 |
8 |
9 |
10 |
11 |
12 |
13 | 71.Tiles。
14 | (1) UrlBasedViewResolver 类: 为它解析的每个 view 实例化一个 viewClass 类的实例。
15 |
16 |
17 |
18 |
19 | (2) ResourceBundleViewResolver 类: 需要一个属性文件，其中包含了它需要使用的视图名和视图类。
20 |
21 |
22 |
23 |
24 | (3) SimpleSpringPreparerFactory 和 SpringBeanPreparerFactory:
25 | 基于指定的 preparer 类，指定 SimpleSpringPreparerFactory 自动装配 ViewPreparer 实体，
26 | 不但应用 Spring 的容器回调而且应用配置 Spring BeanPostProcessors。
27 | 指定 SpringBeanPreparerFactory 来操作指定 preparer 名称，而不是类，
28 | 从 DispatcherServlet 的应用上下文获取相应的 Spring bean。
29 |
30 | 72.Velocity 和 FreeMarker。
31 | (1) Context 配置:
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 | (2) 高级配置:
47 |
48 |
49 |
50 |
53 |
54 |
55 |
56 |
57 | (3) 绑定支持和表单处理:
58 | 用于绑定的宏: org.springframework.web.servlet.view.velocity 包中的 spring.vm 文件和
59 | org.springframework.web.servlet.view.freemarker 包中的 spring.ftl 文件。
60 |
61 | 73.XSLT。
62 | XSLT 是一种用于 XML 的转换语言，并作为一种在 web 应用中使用的 view 层技术广为人知。
63 | 把模型数据转化为 XML:
64 | public class HomePage extends AbstractXsltView {
65 | protected Source createXsltSource(Map model, String rootName, HttpServletRequest
66 | request, HttpServletResponse response) throws Exception {
67 | Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
68 | Element root = document.createElement(rootName);
69 | List words = (List) model.get("wordList");
70 | for (Iterator it = words.iterator(); it.hasNext();) {
71 | String nextWord = (String) it.next();
72 | Element wordNode = document.createElement("word");
73 | Text textNode = document.createTextNode(nextWord);
74 | wordNode.appendChild(textNode);
75 | root.appendChild(wordNode);
76 | }
77 | return new DOMSource(root);
78 | }
79 | }
80 | ```
81 |
--------------------------------------------------------------------------------
/Reading-Notes/CPlusPlusPrimerPlus/CPlusPlusPrimerPlus.md:
--------------------------------------------------------------------------------
1 | 《C++ Primer Plus (第6版)》 :books:
2 |
3 | > [美] Stephen Prata 著 人民邮电出版社
4 |
5 | ```c++
6 | 1.4 种让程序访问名称空间 std 的方法：
7 | (1) 将 using namespace std; 放在函数定义之前，让文件中所有的函数都能够使用名称空间 std 中所有元素。
8 | (2) 将 using namespace std; 放在特定的函数定义中，让该函数能够使用名称空间 std 中的所有元素。
9 | (3) 在特定的函数中使用类似 using std::cout; 这样的编译指令，而不是 using namespace std;，
10 | 让该函数能够使用指定的元素。
11 | (4) 完全不使用编译指令 using，而在需要使用名称空间 std 中的元素时，使用前缀 std::，
12 | 如：std::cout << "test" << std::endl;
13 |
14 | 2.使用 new 和 delete 时的规则：
15 | (1) 不要使用 delete 来释放不是 new 分配的内存。
16 | (2) 不要使用 delete 释放同一个内存块两次。
17 | (3) 如果使用 new[] 为数组分配内存，则应使用 delete[] 来释放。
18 | (4) 如果使用 new 为一个实体分配内存，则应使用 delete (没有方括号) 来释放。
19 | (5) 对空指针应用 delete 是安全的。
20 |
21 | 3.函数探幽：
22 | (1) 函数是 C++ 的编程模块。要使用函数，必须提供定义和原型，并调用该函数。函数定义是实现函数功能的代码；
23 | 函数原型描述了函数的接口：传递给函数的值的数目和种类以及函数的返回类型。函数调用使得程序将参数传递给函数，
24 | 并执行函数的代码。
25 | (2) 在默认情况下，C++ 函数按值传递参数。这意味着函数定义中的形参是新的变量，它们被初始化为函数调用所提供的值。
26 | 因此，C++ 函数通过使用拷贝，保护了原始数据的完整性。
27 | (3) C++ 将数组名视为数组第一个元素的地址。从技术上讲，这仍然是按值传递的，因为指针是原始地址的拷贝，
28 | 但函数将使用指针来访问原始数组的内容。当且仅当声明函数的形参时，下面两个声明才是等价的：
29 | typeName arr[];
30 | typeName * arr;
31 | 这两个声明都表明，arr 是指向 typeName 的指针，但在编写函数代码时，可以像使用数组名那样使用 arr 来访问元素：arr[i]。
32 | 即使在传递指针时，也可以将形参声明为 const 指针，来保护原始数据的完整性。由于传递数据的地址时，并不会传输有关数组长度
33 | 的信息，因此通常将数组长度作为独立的参数来传递。另外也可传递两个指针(其中一个指向数组开头，
34 | 另一个指向数组末尾的下一个元素)，以指定一个范围，就像 STL 使用的算法一样。
35 | (4) C++ 提供了 3 种表示 C-风格字符串的方法：字符数组、字符串常量和字符串指针。它们的类型都是 char* (char 指针)，
36 | 因此被作为 char* 类型参数传递给函数。C++ 使用空值字符 (\0) 来结束字符串，因此字符串函数检测空值字符来确定字符串的结尾。
37 | (5) C++ 还提供了 string 类，用于表示字符串。函数可以接受 string 对象作为参数以及将 string 对象作为返回值。
38 | string 类的方法 size() 可用于判断其存储的字符串的长度。
39 | (6) C++ 处理结构的方式与基本类型完全相同，这意味着可以按值传递结构，并将其用作函数的返回类型。然而，如果结构非常大，
40 | 则传递结构指针的效率将更高，同时函数能够使用原始数据。这些考虑因素也适用于类对象。
41 | (7) C++ 函数可以是递归的，也就是说，函数代码中可以包括对函数本身的调用。
42 | (8) C++ 函数名与函数地址的作用相同。通过将函数指针作为参数，可以传递要调用的函数的名称。
43 | (9) C++ 扩展了 C 语言的函数功能。通过将 inline 关键字用于函数定义，并在首次调用该函数前提供其函数定义，可以使得
44 | C++ 编译器将该函数视为内联函数。也就是说，编译器不是让程序跳到独立的代码段，以执行函数，而是用相应的代码替换函数调用。
45 | 只有在函数很短时才能采用内联方式。
46 | (10) 引用变量是一种伪装指针，它允许为变量创建别名。引用变量主要被用作处理结构和类对象的函数参数。通常，
47 | 被声明为特定类型引用的标识符只能指向这种类型的数据；然而，如果一个类 (如 ofstream) 是从另一个类 (如 ostream) 派生
48 | 出来的，则基类引用可以指向派生类对象。
49 | (11) C++ 原型让您能够定义参数的默认值。如果函数调用省略了相应的参数，则程序将使用默认值；如果函数调用提供了参数值，
50 | 则程序将使用这个值 (而不是默认值)。只能在参数列表中从右到左提供默认参数。因此，如果为某个参数提供默认值，则必须为该
51 | 参数右边所有的参数提供默认值。
52 | (12) 函数的特征标是其参数列表。程序员可以定义两个同名函数，只要其特征标不同。这被称为函数多态或函数重载。通常，
53 | 通过重载函数来为不同的数据类型提供相同的服务。
54 | (13) 函数模板自动完成重载函数的过程。只需使用泛型和具体算法来定义函数，编译器将为程序中使用的特定参数类型生成正确
55 | 的函数定义。
56 |
57 | 4.应尽可能使用 const。
58 | 将引用参数声明为常量数据的引用的理由有三个：
59 | (1) 使用 const 可以避免无意中修改数据的编程错误；
60 | (2) 使用 const 使函数能够处理 const 和非 const 实参，否则将只能接受非 const 数据；
61 | (3) 使用 const 引用使函数能够正确生成并使用临时变量。
62 |
63 | 5.何时使用引用参数?
64 | (1) 使用引用参数的两个主要原因：
65 | ① 程序员能够修改调用函数中的数据对象。
66 | ② 通过传递引用而不是整个数据对象，可以提高程序的运行速度。
67 | (2) 对于使用传递的值而不作修改的函数：
68 | ① 如果数据对象很小，如内置数据类型或小型结构，则按值传递。
69 | ② 如果数据对象是数组，则使用指针，因为这是唯一的选择，并将指针声明为指向 const 的指针。
70 | ③ 如果数据对象是较大的结构，则使用 const 指针或 const 引用，以提高程序的效率。
71 | 这样可以节省复制结构所需的时间和空间。
72 | ④ 如果数据对象是类对象，则使用 const 引用。类设计的语义常常要求使用引用，这是 C++ 新增这项特性的主要原因。因此，
73 | 传递类对象参数的标准方式是按引用传递。
74 | (3) 对于修改调用函数中数据的函数：
75 | ① 如果数据对象是内置数据类型，则使用指针。如果看到诸如 fixit(&x) 这样的代码 (其中 x 是 int)，则很明显，
76 | 该函数将修改 x。
77 | ② 如果数据对象是数组，则只能使用指针。
78 | ③ 如果数据对象是结构，则使用引用或指针。
79 | ④ 如果数据对象是类对象，则使用引用。
80 |
81 | 6.第三代具体化 (ISO/ANSI C++ 标准)。
82 | (1) 对于给定的函数名，可以有非模板函数 (non template function)、模板函数 (template prototype)
83 | 和显示具体化模板函数 (explicit specialization) 以及它们的重载版本。
84 | (2) 显示具体化的原型和定义应以 template<> 打头，并通过名称来指出类型。
85 | (3) 具体化优先于常规模版，而非模版函数优先于具体化和常规模板。
86 | // 非模板函数 (non template function)
87 | void Swap(job &, job &);
88 | // 模板函数 (template prototype)
89 | template
90 | void Swap(T &, T &);
91 | // 显示具体化模板函数 (explicit specialization)
92 | template <> void Swap(job &, job &);
93 | ```
94 |
--------------------------------------------------------------------------------
/Reading-Notes/WebMiddleware.md:
--------------------------------------------------------------------------------
1 | 《大型网站系统与Java中间件实践》 :books:
2 |
3 | > 曾宪杰 著 电子工业出版社
4 |
5 | ```java
6 | 1.网络 IO 实现方式：
7 | (1) BIO 方式：Blocking IO，阻塞 IO，一个 Socket 套接字需要使用一个线程来进行处理。
8 | (2) NIO 方式：Nonblocking IO，非阻塞 IO，基于事件驱动思想，采用 Reactor 模式。
9 | (3) AIO 方式：Asynchronous IO，异步 IO，采用 Proactor模式。
10 |
11 | 2.分布式系统的难点：
12 | (1) 缺乏全局时钟。
13 | (2) 面对故障独立性。
14 | (3) 处理单点故障。
15 | (4) 事务的挑战。
16 |
17 | 3.集群 Session 同步：
18 | (1) Session Sticky：让同样的 Session 请求每次都发送到同一个服务器处理。
19 | (2) Session Replication：在 Web 服务器之间增加会话数据同步。
20 | (3) Session 数据集中存储：把 Session 数据集中存储起来。
21 | (4) Cookie Based：通过 Cookie 来传递 Session 数据。
22 |
23 | 4.Java 并发编程的类、接口和方法：
24 | (1) 线程池：ThreadPoolExecutor 和定时线程池 ScheduledThreadPoolExecutor。
25 | (2) synchronized。
26 | (3) ReentrantLock 可重入锁和 ReentrantReadWriteLock。
27 | lock.lock();
28 | try {
29 | // do something
30 | }
31 | finally {
32 | lock.unlock();
33 | }
34 | (4) volatile：实现变量可见性，但不保证原子性。
35 | (5) Atomics：原子类。
36 | (6) wait、notify、notifyAll。
37 | public void testWait() throws InterruptedException {
38 | synchronized (this) {
39 | this.wait();
40 | }
41 | }
42 | public void testNotify() {
43 | synchronized (this) {
44 | this.notify();
45 | }
46 | }
47 | (7) CountDownLatch：当多个线程都达到了预期状态或完成预期工作时触发事件。
48 | (8) CyclicBarrier：协同多个线程，让多个线程在这个屏障前等待，直到所有线程都到达了这个屏障时，再一起继续执行后面动作。
49 | (9) Semaphore：信号量。
50 | semaphore.acquire();
51 | try {
52 | //调用远程通信的方法
53 | }
54 | finally {
55 | semaphore.release();
56 | }
57 | (10) Exchanger：用于在两个线程之间进行数据交换。
58 | (11) Future 和 FutureTask。
59 | (12) 并发容器：CopyOnWrite。
60 |
61 | 5.动态代理：
62 | public void testDynamicProxy() {
63 | Calculator calculator = new CalculatorImpl();
64 | LogHandler lh = new LogHandler(calculator);
65 | Calculator proxy = (Calculator) Proxy.newProxyInstance(calculator.getClass().getClassLoader(),
66 | calculator.getClass().getInterfaces(), lh);
67 | proxy.add(1, 1);
68 | }
69 |
70 | public class LogHandler implements InvocationHandler {
71 | Object obj;
72 | LogHandler(Object obj) {
73 | this.obj = obj;
74 | }
75 | public Object invoke(Object obj1, Method method, Object[] args) throws Throwable {
76 | this.doBefore();
77 | Object o = method.invoke(obj, args);
78 | this.doAfter();
79 | return o;
80 | }
81 | public void doBefore() {
82 | System.out.println("do this before");
83 | }
84 | public void doAfter() {
85 | System.out.println("do this after");
86 | }
87 | }
88 |
89 | 6.反射：
90 | (1) 获取对象属于哪个类.
91 | Class class = object.getClass();
92 | (2) 获取类的信息.
93 | String className = class.getName(); //获取类名
94 | Method[] methods = class.getDeclaredMethods(); //获取类中定义的方法
95 | Field[] fields = class.getDeclaredFields(); //获取类中定义的成员
96 | (3) 构建对象.
97 | Class.forName("ClassName").newInstance();
98 | (4) 动态执行方法.
99 | Method method = class.getDeclaredMethod("add", int.class, int.class);
100 | method.invoke(this, 1, 1);
101 | (5) 动态操作属性.
102 | Field field = class.getDeclaredField("name");
103 | field.set(this, "Test");
104 |
105 | 7.数据库从单机到分布式的挑战与应对：
106 | 1) 从应用使用单机数据库开始。
107 | 2) 数据库垂直/水平拆分的困难。
108 | 3) 单机变为多机后，事务如何处理。
109 | (1) 大型网站一致性的基础理论——CAP/BASE。
110 | CAP：Consistency：一致性、Availability：可用性、Partition-Tolerance：分区容忍性。
111 | (2) 比两阶段提交更轻量一些的 Paxos 协议。
112 | (3) 集群内数据一致性的算法：Quorum 和 Vector Clock算法。
113 | 4) 多机的 Sequence 问题与处理。
114 | 方案：把所有的 ID 集中存放在一个地方进行管理，对每个 ID 序列独立管理，每台机器使用 ID 时都从这个
115 | ID 生成器上取。
116 | 5) 应对多机的数据查询。
117 | (1) 跨库 Join。
118 | (2) 外键约束。
119 | (3) 分库分表后查询：非排序分页——A.等步长分页，B.等比例分页。
120 | ```
121 |
122 | * 8.数据层结构图：
123 | 
124 |
--------------------------------------------------------------------------------
/Reading-Notes/JavaWebTechnologyInsider.md:
--------------------------------------------------------------------------------
1 | 《深入分析 Java Web 技术内幕》 :books:
2 |
3 | > 许令波 著 电子工业出版社
4 |
5 | ```java
6 | 1.当一个用户在浏览器里输入 www.taobao.com 这个 URL，将会会发生什么？
7 | 首先请求 DNS 把这个域名解析成对应的 IP 地址，然后根据这个 IP 地址在互联网上找到对应的服务器，向这个服务器发起
8 | 一个 get 请求，由这个服务器决定返回默认的数据资源给访问的用户。在服务器端实际上还有很多复杂的业务逻辑：服务器
9 | 可能有很多台，到底指定哪台服务器来处理请求，这需要一个负载均衡设备来平均分配所有用户请求；还有请求的数据是存储
10 | 在分布式缓存里还是一个静态文件中，或是在数据库里；当数据返回浏览器时，浏览器解析数据发现还有一些静态资源
11 | (如 CSS、JS 或者图片) 时又会发起另外的 HTTP 请求，而这些请求很可能会在 CDN 上，那么 CDN 服务器又会处理这个
12 | 用户的请求，大体上一个用户请求会涉及这么多的操作。
13 | ```
14 |
15 | B/S 网络架构
16 |
17 | DNS 域名解析
18 |
19 | CDN 架构
20 |
21 | Javac 组件
22 |
23 | Bean 工厂的继承层次关系
24 |
25 | ```java
26 | 2.Javac 编译器主要有四大模块：词法分析器、语法分析器、语义分析器和代码生成器。
27 |
28 | 3.GC 日志格式：
29 | [GC [: -> (total size1), secs]
30 | -> (total size2), secs]
31 | 格式说明：
32 | (1) 表示收集器的名称。
33 | (2) 表示 Young 区在 GC 前占用的内存。
34 | (3) 表示 Young 区在 GC 后占用的内存。
35 | (4) 表示 Young 区局部收集时 JVM 暂停处理的时间。
36 | (5) 表示 JVM Heap 在 GC 前占用的内存。
37 | (6) 表示 JVM Heap 在 GC 后占用的内存。
38 | (7) 表示 GC 过程中 JVM 暂停处理的总时间。
39 | 可以根据日志判断是否有内存泄漏，如果 - =
40 | - ，则表明这次 GC 对象 100% 被回收，没有对象进入 Old 区或者 Perm 区。
41 | 如果等号左边的值大于等号右边的值，那么差值就是这次回收对象进入 Old 区或者 Perm 区的大小。如果随着时间的延长
42 | 的值一直在增长，而且 Full GC 很频繁，那么很可能就是内存泄露了。
43 |
44 | 4.分布式 Session 框架。
45 | (1) Session 的配置：
46 |
47 | sessinonID
48 | sessinonID
49 | 9000
50 | true
51 |
52 | (2) Cookie 的配置：
53 |
54 | cookie
55 |
56 | 1
57 | /wp
58 | xulingbo.net
59 | false
60 | false
61 |
62 | (3) 跨域名共享 Cookie (跨域名同步 Session):
63 | 需要一个跳转应用，这个应用可以被一个或多个域名访问，它的主要功能是从一个域名下取得 sessionID，然后将这个
64 | sessionID 同步到另一个域名下。这个 sessionID 其实就是一个 Cookie，相当于我们经常遇到的 JSESSIONID，
65 | 所以要实现两个域名下的 Session 同步，必须要将同一个 sessionID 作为 Cookie 写到两个域名下。
66 | ```
67 |
68 | 分布式 Session 框架的架构
69 |
70 | JVM 体系结构
71 |
72 | Request 在容器中的路由
73 |
74 | Tomcat 的总体架构
75 |
76 | Jetty 的基本架构
77 |
78 | ```java
79 | 5.JVM 的体系结构：
80 | JVM 的结构基本上由 4 部分组成：
81 | (1) 类加载器，在 JVM 启动时或者在类运行时将需要的 class 加载到 JVM 中。
82 | (2) 执行引擎，任务是负责执行 class 文件中包含的字节码指令，相当于实际机器上的 CPU。
83 | (3) 内存区，将内存划分成若干个区模拟实际机器上的存储、记录和调度功能模块，如实际机器上的各种功能的寄存器
84 | 或者 PC 指针的记录器等。
85 | (4) 本地方法调用，调用 C 或 C++ 实现的本地方法代码返回结果。
86 | ```
87 |
88 | NIO 相关类图
89 |
90 | 词法分析器设计的类图
91 |
92 | ClassLoader 的类层次结构
93 |
94 | Jetty 的主要组件的类图
95 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringFramework/SpringFramework8.md:
--------------------------------------------------------------------------------
1 | 《Spring 2.5开发手册》 :books:
2 |
3 | ```java
4 | 39.集成测试。
5 | (1) 上下文管理及缓存: Spring 集成测试支持框架提供了 ApplicationContext 的持久化载入和这些上下文的缓存机制。
6 | (2) 测试 fixtures 依赖注入: 可以在各种测试场景中重用应用上下文
7 | (例如配置 Spring 管理的对象图， 事务代理 DataSource 等)，从而能避免为单个的测试案例重复进行测试 fixture 搭建。
8 | (3) 事务管理: Spring 集成测试支持框架可以通过调用一个继承下来的钩子(Hook)方法或声明特定注解来让事务提交而不是回滚。
9 | (4) 集成测试支持类: ApplicationContext - 用来进行显式 bean 查找或整体测试上下文状态。
10 | JdbcTemplate 或 SimpleJdbcTemplate - 用来查询并确认状态。
11 |
12 | 40.常用注解。
13 | (1) @IfProfileValue
14 | @IfProfileValue(name="test-groups", values={"unit-tests", "integration-tests"})
15 | public void testProcessWhichRunsForUnitOrIntegrationTestGroups() {
16 | // some logic that should run only for unit and integration test groups
17 | }
18 | (2) @ProfileValueSourceConfiguration
19 | @ProfileValueSourceConfiguration(CustomProfileValueSource.class)
20 | public class CustomProfileValueSourceTests {
21 | // class body...
22 | }
23 | (3) @DirtiesContext
24 | @DirtiesContext
25 | public void testProcessWhichDirtiesAppCtx() {
26 | // some logic that results in the Spring container being dirtied
27 | }
28 | (4) @ExpectedException
29 | @ExpectedException(SomeBusinessException.class)
30 | public void testProcessRainyDayScenario() {
31 | // some logic that should result in an Exception being thrown
32 | }
33 | (5) @Timed
34 | @Timed(millis=1000)
35 | public void testProcessWithOneSecondTimeout() {
36 | // some logic that should not take longer than 1 second to execute
37 | }
38 | (6) @Repeat
39 | @Repeat(10)
40 | public void testProcessRepeatedly() { }
41 | (7) @Rollback
42 | @Rollback(false)
43 | public void testProcessWithoutRollback() { }
44 | (8) @NotTransactional
45 | @NotTransactional
46 | public void testProcessWithoutTransaction() { }
47 |
48 | 41.JUnit 3.8 遗留支持。
49 | (1) 上下文管理及缓存:
50 | protected String[] getConfigLocations();
51 | protected String[] getConfigPaths();
52 | protected String getConfigPath();
53 | (2) 测试 fixture 依赖注入:
54 | public final class HibernateTitleDaoTests extends AbstractDependencyInjectionSpringContextTests {
55 | // this instance will be (automatically) dependency injected
56 | private HibernateTitleDao titleDao;
57 | // a setter method to enable DI of the 'titleDao' instance variable
58 | public void setTitleDao(HibernateTitleDao titleDao) {
59 | this.titleDao = titleDao;
60 | }
61 | public void testLoadTitle() throws Exception {
62 | Title title = this.titleDao.loadTitle(new Long(10));
63 | assertNotNull(title);
64 | }
65 | // specifies the Spring configuration to load for this test fixture
66 | protected String[] getConfigLocations() {
67 | return new String[] { "classpath:com/foo/daos.xml" };
68 | }
69 | }
70 |
71 | 42.Spring TestContext Framework。
72 | 事务管理:
73 | @RunWith(SpringJUnit4ClassRunner.class)
74 | @ContextConfiguration
75 | @TransactionConfiguration(transactionManager="txMgr", defaultRollback=false)
76 | @Transactional
77 | public class FictitiousTransactionalTest {
78 | @BeforeTransaction
79 | public void verifyInitialDatabaseState() {
80 | // logic to verify the initial state before a transaction is started
81 | }
82 |
83 | @Before
84 | public void setUpTestDataWithinTransaction() {
85 | // set up test data within the transaction
86 | }
87 |
88 | @Test
89 | // overrides the class-level defaultRollback setting
90 | @Rollback(true)
91 | public void modifyDatabaseWithinTransaction() {
92 | // logic which uses the test data and modifies database state
93 | }
94 |
95 | @After
96 | public void tearDownWithinTransaction() {
97 | // execute "tear down" logic within the transaction
98 | }
99 |
100 | @AfterTransaction
101 | public void verifyFinalDatabaseState() {
102 | // logic to verify the final state after transaction has rolled back
103 | }
104 |
105 | @Test
106 | @NotTransactional
107 | public void performNonDatabaseRelatedAction() {
108 | // logic which does not modify database state
109 | }
110 | }
111 | ```
112 |
--------------------------------------------------------------------------------
/Learning-Notes/FamousBlogs.md:
--------------------------------------------------------------------------------
1 | H.博客
2 |
3 |
97 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringSourceDepthParsing.md:
--------------------------------------------------------------------------------
1 | 《Spring 源码深度解析》 :books:
2 |
3 | > 郝佳 著 人民邮电出版社
4 |
5 | Spring 容器加载相关类
6 |
7 | Spring 配置文件读取相关类
8 |
9 | ```java
10 | 1.Spring 的整体架构：
11 | (1) Core Container：核心容器包含有 Core、Beans、Context 和 Expression Language 模块。
12 | Core 和 Beans 模块是框架的基础部分，提供 IoC (控制反转) 和依赖注入特性。BeanFactory 提供对 Factory 模式的经典
13 | 实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。
14 | ① Core 模块主要包含 Spring 框架基本的核心工具类，Spring 的其他组件都要使用到这个包里的类，Core 模块是其它组件
15 | 的基本核心。
16 | ② Beans 模块是所有应用都要用到的，它包含访问配置文件、创建和管理 bean 以及进行 Inversion of Control /
17 | Dependency Injection (IoC / DI) 操作相关的所有类。
18 | ③ Context 模块构建于 Core 和 Beans 模块基础之上，提供了一种类似于 JNDI 注册器的框架式的对象访问方法。Context
19 | 模块继承了 Beans 的特性，为 Spring 核心提供了大量扩展，添加了对国际化 (例：资源绑定)、事件传播、资源加载和对
20 | Context 的透明创建的支持。Context 模块同时也支持 J2EE 的一些特性，例如 EJB、JMX 和基础的远程处理。
21 | ApplicationContext 接口是 Context 模块的关键。
22 | ④ Expression Language 模块提供了一个强大的表达式语言用于在运行时查询和操纵对象。它是 JSP 2.1 规范中定义的
23 | unifed expression language 的一个扩展。该语言支持设置/获取属性的值、属性的分配、方法的调用、访问数组上下文、
24 | 容器和索引器、逻辑和算术运算符、命名变量以及从 Spring 的 IoC 容器中根据名称检索对象。它也支持 list 投影、选择
25 | 和一般的 list 聚合。
26 | (2) Data Access / Integration：该层包含 JDBC、ORM、OXM、JMS 和 Transaction 模块。
27 | ① JDBC 模块提供一个 JDBC 抽象层，它可以消除冗长的 JDBC 编码和解析数据库厂商特有的错误代码。这个模块包含了
28 | Spring 对 JDBC 数据访问进行封装的所有类。
29 | ② ORM 模块为流行的对象-关系映射 API，如 JPA、JDO、Hibernate、iBatis 等，提供了一个交互层。利用 ORM 封装包，
30 | 可以混合使用所有 Spring 提供的特性进行 O/R 映射。如：简单声明性事务管理。
31 | ③ OXM 模块提供了一个对 Object/XML 映射实现的抽象层，Object/XML 映射实现包括 JAXB、Castor、XMLBeans、JiBX
32 | 和 XStream。
33 | ④ JMS (Java Messaging Service) 模块主要包含了一些制造和消费消息的特性。
34 | ⑤ Transaction 模块支持编程和声明性的事务管理，这些事务类必须实现特定的接口，并且对所有的 POJO 都适用。
35 | (3) Web：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。Spring 框架支持与
36 | Jakarta Struts 的集成。Web 层包含了 Web、Web-Servlet、Web-Struts 和 Web-Porlet 模块。
37 | ① Web 模块：提供了基础的面向 Web 的集成特性。例如：多文件上传、使用 servlet listeners 初始化 IoC 容器以及
38 | 一个面向 Web 的应用上下文。它还包含 Spring 远程支持中 Web 的相关部分。
39 | ② Web-Servlet 模块 web.servlet.jar：该模块包含 Spring 的 model-view-controller (MVC) 实现。Spring 的
40 | MVC 框架使得模型范围内的代码和 web forms 之间能够清楚地分离开来，并与 Spring 框架的其它特性集成在一起。
41 | ③ Web-Struts 模块：该模块提供了对 Struts 的支持，使得类在 Spring 应用中能够与一个典型的 Struts Web 层集成
42 | 在一起。注意：该支持在 Spring 3.0 是 deprecated 的。
43 | ④ Web-Porlet 模块：提供了用于 Porlet 环境和 Web-Servlet 模块的 MVC 的实现。
44 | (4) AOP：AOP 模块提供了一个符合 AOP 联盟标准的面向切面编程的实现，它让你可以定义方法拦截点和切点，
45 | 从而将逻辑代码分开，降低它们之间的耦合性。利用 source-level 的元数据功能，还可以将各种行为信息合并到你的代码中，
46 | 这有点像 .Net 技术中的 attribute 概念。
47 | ① Aspects 模块提供了对 AspectJ 的集成支持。
48 | ② Instrumentation 模块提供了 class instrumentation 支持和 classloader 实现，使得可以在特定的
49 | 应用服务器上使用。
50 | (5) Test：Test 模块支持使用 JUnit 和 TestNG 对 Spring 组件进行测试。
51 |
52 | 2.Spring 容器加载相关类：
53 | (1) AliasRegistry：定义对 alias 的简单增删改等操作。
54 | (2) SimpleAliasRegistry：主要使用 map 作为 alias 的缓存，并对接口 AliasRegistry 进行实现。
55 | (3) SingletonBeanRegistry：定义对单例的注册及获取。
56 | (4) BeanFactory：定义获取 bean 及 bean 的各种属性。
57 | (5) DefaultSingletonBeanRegistry：对接口 SingletonBeanRegistry 各函数的实现。
58 | (6) HierarchicalBeanFactory：继承 BeanFactory，也就是在 BeanFactory 定义的功能的基础上增加了对 parentFactory
59 | 的支持。
60 | (7) BeanDefinitionRegistry：定义对 BeanDefinition 的各种增删改操作。
61 | (8) FactoryBeanRegistrySupport：在 DefaultSingletonBeanRegistry 基础上增加了对 FactoryBean 的特殊处理功能。
62 | (9) ConfigurableBeanFactory：提供配置 Factory 的各种方法。
63 | (10) ListableBeanFactory：根据各种条件获取 bean 的配置清单。
64 | (11) AbstractBeanFactory：综合 FactoryBeanRegistrySupport 和 ConfigurableBeanFactory 的功能。
65 | (12) AutowireCapableBeanFactory：提供创建 bean、自动注入、初始化以及应用 bean 的后处理器。
66 | (13) AbstractAutowireCapableBeanFactory：综合 AbstractBeanFactory 并对接口 AutowireCapableBeanFactory
67 | 进行实现。
68 | (14) ConfigurableListableBeanFactory：BeanFactory 配置清单，指定忽略类型及接口等。
69 | (15) DefaultListableBeanFactory：综合上面所有功能，主要是对 Bean 注册后的处理。
70 |
71 | 3.Spring 配置文件相关类：
72 | (1) ResourceLoader：定义资源加载器，主要应用于根据给定的资源文件地址返回对应的 Resource。
73 | (2) BeanDefinitionReader：主要定义资源文件读取并转换为 BeanDefinition 的各个功能。
74 | (3) EnvironmentCapable：定义获取 Environment 方法。
75 | (4) DocumentLoader：定义从资源文件加载到转换为 Document 的功能。
76 | (5) AbstractBeanDefinitionReader：对 EnvironmentCapable、BeanDefinitionReader 类定义的功能进行实现。
77 | (6) BeanDefinitionDocumentReader：定义读取 Document 并注册 BeanDefinition 功能。
78 | (7) BeanDefinitionParserDelegate：定义解析 Element 的各种方法。
79 | ```
80 |
--------------------------------------------------------------------------------
/Reading-Notes/EffectiveCPlusPlus/EffectiveCPlusPlus2.md:
--------------------------------------------------------------------------------
1 | 《Effective C++》 :books:
2 |
3 | > Scott Meyers 著 电子工业出版社
4 |
5 | ```c++
6 | 11.在 operator= 中处理"自我赋值"。
7 | (1) 确保当对象自我赋值时 operator= 有良好行为。其中技术包括比较"来源对象"和"目标对象"的地址、
8 | 精心周到的语句顺序、以及 copy-and-swap。
9 | 让 operator= 具备"异常安全性"往往自动获得"自我赋值安全"的回报。
10 | Widget& Widget::operator=(const Widget& rhs) {
11 | Bitmap* pOrig = pb; // 记录原先的 pb
12 | pb = new Bitmap(*rhs.pb); // 令 pb 指向 *pb 的一个副本
13 | delete pOrig; // 删除原先的 pb
14 | return *this;
15 | }
16 | copy-and-swap 技术:
17 | class Widget {
18 | ...
19 | void swap(Widget& rhs); // 交换 *this 和 rhs 的数据
20 | ...
21 | };
22 | Widget& Widget::operator=(const Widget& rhs) {
23 | Widget temp(rhs); // 为 rhs 数据制作一份副本
24 | swap(temp); // 将 *this 数据和上述副本的数据交换
25 | return *this;
26 | }
27 | (2) 确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。
28 |
29 | 12.复制对象时勿忘其每一个成分。
30 | (1) copying 函数应该确保复制"对象内的所有成员变量"及"所有 base class 成分"。
31 | (2) 不要尝试以某个 copying 函数实现另一个 copying 函数。应该将共同机能放进第三个函数中，并由两个
32 | copying 函数共同调用。
33 |
34 | 13.以对象管理资源。
35 | 常见的系统资源：动态分配的内存、文件描述器(file descriptors)、互斥锁(mutex locks)、图形界面中的字型和笔刷、
36 | 数据库连接、以及网络 sockets。
37 | (1) 为防止资源泄漏，请使用 RAII (资源取得时机便是初始化时机，Resource Acquisition Is Initialization) 对象，
38 | 它们在构造函数中获得资源并在析构函数中释放资源。
39 | (2) 两个常被使用的 RAII classes 分别是 tr1::shared_ptr 和 auto_ptr。前者通常是较佳选择，因为其 copy 行为
40 | 比较直观。若选择 auto_ptr，复制动作会使它(被复制物)指向 null。
41 | void f1() {
42 | std::auto_ptr pInv(createInvestment()); // 经由 auto_ptr 的析构函数自动删除 pInv
43 | ...
44 | }
45 | void f2() {
46 | // 经由 shared_ptr 的析构函数自动删除 pInv
47 | std::tr1::shared_ptr pInv(createInvestment());
48 | ...
49 | }
50 |
51 | 14.在资源管理类中小心 copying 行为。
52 | (1) 复制 RAII 对象必须一并复制它所管理的资源，所以资源的 copying 行为决定 RAII 对象的 copying 行为。
53 | (2) 普遍而常见的 RAII class copying 行为是：抑制 copying、施行引用计数法(reference counting)。
54 | 不过其它行为也都可能被实现。
55 | class Lock {
56 | public:
57 | // 以某个 Mutex 初始化 shared_ptr 并以 unlock 函数为删除器
58 | explicit Lock(Mutex* pm) : mutexPtr(pm, unlock) {
59 | lock(mutexPtr.get());
60 | }
61 | private:
62 | std::tr1::shared_ptr mutexPtr; // 使用 shared_ptr 替换 raw pointer
63 | }
64 |
65 | 15.在资源管理类中提供对原始资源的访问。
66 | (1) APIs 往往要求访问原始资源(raw resources)，所以每一个 RAII class
67 | 应该提供一个“取得其所管理之资源”的办法。
68 | (2) 对原始资源的访问可能经由显式转换或隐式转换。一般而言显式转换比较安全，但隐式转换对客户比较方便。
69 | tr1::shared_ptr 和 auto_ptr 都提供一个 get 成员函数，用来执行显式转换，
70 | 它会返回智能指针内部的原始指针(的复件):
71 | int days = daysHeld(pInv.get());
72 | tr1::shared_ptr 和 auto_ptr 重载了指针取值(pointer derfercing)操作符(operator-> 和 operator*)，
73 | 它们允许隐式转换至底部原始指针。
74 |
75 | 16.成对使用 new 和 delete 时要采取相同形式。
76 | 如果你在 new 表达式中使用 []，必须在相应的 delete 表达式中也使用 []。如果你在 new 表达式中不使用 []，
77 | 一定不要在相应的 delete 表达式中使用 []。
78 | std::string* stringPtr1 = new std::string;
79 | std::string* stringPtr2 = new std::string[100];
80 | ...
81 | delete stringPtr1; // 删除一个对象
82 | delete [] stringPtr2; // 删除一个由对象组成的数组
83 |
84 | 17.以独立语句将 newed 对象置于智能指针。
85 | 以独立语句将 newed 对象存储于(置入)智能指针内。如果不这样做，一旦异常被抛出，
86 | 有可能导致难以察觉的资源泄漏。
87 | std::tr1::shared_ptr pw(new Widget); // 在单独语句内以智能指针存储 newed 所得对象
88 | processWidget(pw, priority()); // 这个调用动作绝不至于造成泄漏
89 |
90 | 18.让接口容易被正确使用，不易被误用。
91 | (1) 好的接口很容易被正确使用，不容易被误用。你应该在你的所有接口中努力达成这些性质。
92 | (2) “促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容。
93 | (3) "阻止误用"的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。
94 | (4) tr1::shared_ptr 支持定制型删除器(custom deleter)。
95 | 这可防范 DLL 问题，可被用来自动解除互斥锁(mutex)等等。
96 |
97 | 19.设计 class 犹如设计 type。
98 | (1) 新 type 的对象应该如何被创建和销毁?
99 | (2) 对象的初始化和对象的赋值该有什么样的差别?
100 | (3) 新 type 的对象如果被 passed by value(以值传递)，意味着什么?
101 | (4) 什么是新 type 的"合法值"?
102 | (5) 你的新 type 需要配合某个继承图系(inheritance graph)吗?
103 | (6) 你的新 type 需要什么样的转换?
104 | (7) 什么样的操作符和函数对此新 type 而言是合理的?
105 | (8) 什么样的标准函数应该驳回?
106 | (9) 谁该取用新 type 的成员?
107 | (10) 什么是新 type 的"未声明接口"(undeclared interface)?
108 | (11) 你的新 type 有多么一般化?
109 | (12) 你真的需要一个新 type 吗?
110 |
111 | 20.宁以 pass-by-reference-to-const 替换 pass-by-value。
112 | (1) 尽量以 pass-by-reference-to-const 替换 pass-by-value。前者通常比较高效，并可避免切割问题。
113 | bool validateStudent(const Student& s);
114 | (2) 以上规则并不适用于内置类型，以及 STL 的迭代器和函数对象。对它们而言，pass-by-value 往往比较恰当。
115 | ```
116 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringFramework/SpringFramework18.md:
--------------------------------------------------------------------------------
1 | 《Spring 2.5开发手册》 :books:
2 |
3 | ```java
4 | 96.Spring 邮件抽象层。
5 | Spring 邮件抽象层的主要包为 org.springframework.mail。它包括了发送电子邮件的主要接口 MailSender
6 | 和值对象 SimpleMailMessage，它封装了简单邮件的属性如 from, to, cc, subject, text。
7 |
8 | 97.使用 Spring 邮件抽象。
9 | (1) MailSender 和 SimpleMailMessage 的基本用法。
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 | (2) 使用 JavaMailSender 和 MimeMessagePreparator。
23 | import javax.mail.Message;
24 | import javax.mail.MessagingException;
25 | import javax.mail.internet.InternetAddress;
26 | import javax.mail.internet.MimeMessage;
27 | import javax.mail.internet.MimeMessage;
28 | import org.springframework.mail.MailException;
29 | import org.springframework.mail.javamail.JavaMailSender;
30 | import org.springframework.mail.javamail.MimeMessagePreparator;
31 | public class SimpleOrderManager implements OrderManager {
32 | private JavaMailSender mailSender;
33 | public void setMailSender(JavaMailSender mailSender) {
34 | this.mailSender = mailSender;
35 | }
36 | public void placeOrder(final Order order) {
37 | MimeMessagePreparator preparator = new MimeMessagePreparator() {
38 | public void prepare(MimeMessage mimeMessage) throws Exception {
39 | mimeMessage.setRecipient(Message.RecipientType.TO,
40 | new InternetAddress(order.getCustomer().getEmailAddress()));
41 | mimeMessage.setFrom(new InternetAddress("mail@ouc.com"));
42 | mimeMessage.setText("Dear " + order.getCustomer().getFirstName() + " "
43 | + order.getCustomer().getLastName()
44 | + ", thank you for placing order. Your order number is "
45 | + order.getOrderNumber());
46 | }
47 | };
48 | try {
49 | this.mailSender.send(preparator);
50 | }
51 | catch (MailException ex) {
52 | System.err.println(ex.getMessage());
53 | }
54 | }
55 | }
56 |
57 | 98.使用 MimeMessageHelper。
58 | org.springframework.mail.javamail.MimeMessageHelper 是处理 JavaMail 邮件时比较顺手组件之一。
59 | (1) 发送附件和嵌入式资源(inline resources)。
60 | JavaMailSenderImpl sender = new JavaMailSenderImpl();
61 | sender.setHost("mail.host.com");
62 | MimeMessage message = sender.createMimeMessage();
63 | // use the true flag to indicate you need a multipart message
64 | MimeMessageHelper helper = new MimeMessageHelper(message, true);
65 | helper.setTo("test@host.com");
66 | helper.setText("Check out this image!");
67 | // let's attach the infamous windows Sample file (this time copied to c:/)
68 | FileSystemResource file = new FileSystemResource(new File("c:/Sample.jpg"));
69 | helper.addAttachment("CoolImage.jpg", file);
70 | // helper.addInline("identifier1234", file);
71 | sender.send(message);
72 |
73 | (2) 使用模板来创建邮件内容。
74 |
75 | 99.使用 OpenSymphony Quartz 调度器。
76 | (1) 使用 JobDetailBean。
77 | JobDetail 对象保存运行一个任务所需的全部信息。Spring 提供一个叫作 JobDetailBean 的类让 JobDetail
78 | 能对一些有意义的初始值进行初始化。
79 | (2) 使用 MethodInvokingJobDetailFactoryBean。
80 |
81 |
82 |
83 |
84 | (3) 使用 triggers 和 SchedulerFactoryBean 来包装任务。
85 | Spring 提供两个子类 triggers，分别为 CronTriggerBean 和 SimpleTriggerBean。
86 |
87 | 100.使用 JDK Timer 支持类。
88 | (1) 创建定制的 timers。
89 | (2) 使用 MethodInvokingTimerTaskFactoryBean 类。
90 | (3) 使用 TimerFactoryBean 来设置任务。
91 |
92 | 101.Spring TaskExecutor 抽象。
93 | (1) TaskExecutor 接口。
94 | Spring 的 TaskExecutor 接口等同于 java.util.concurrent.Executor 接口。
95 | (2) TaskExecutor 类型：SimpleAsyncTaskExecutor 类、SyncTaskExecutor 类、ConcurrentTaskExecutor 类、
96 | SimpleThreadPoolTaskExecutor 类、ThreadPoolTaskExecutor 类、TimerTaskExecutor 类、WorkManagerTaskExecutor 类。
97 | ```
98 |
--------------------------------------------------------------------------------
/Reading-Notes/DataBase/DB2/Procedures.md:
--------------------------------------------------------------------------------
1 | ［DB2 数据库］ :memo:
2 |
3 | ```SQL
4 | 1.打开命令行窗口 / 打开控制中心 / 打开命令编辑器：db2cmd / db2cmd db2cc / db2cmd db2ce;
5 |
6 | 2.启动 / 停止数据库实例：db2start / db2stop;
7 |
8 | 3.创建数据库：db2 create db [dbname];
9 |
10 | 4.连接到数据库：db2 connect to [dbname] user [username] using [password];
11 |
12 | 5.断开数据库连接：db2 connect reset;
13 |
14 | 6.列出所有数据库：db2 list db directory;
15 |
16 | 7.列出所有激活的数据库：db2 list active databases;
17 |
18 | 8.列出所有数据库配置：db2 get db cfg;
19 |
20 | 9.删除数据库(慎用，除了删库跑路，ヽ(≧□≦)ノ)：db2 drop database [dbname];
21 |
22 | 10.列出所有用户表：db2 list tables;
23 |
24 | ----------------------------------------------------------------------------------------------------
25 | 11.显示所有可用的缓冲池: db2 select * from syscat.bufferpools;
26 |
27 | 12.创建缓冲池: db2 create bufferpool [bufferpool_name] pagesize [size];
28 |
29 | 13.删除缓冲池: drop bufferpool [bufferpool_name];
30 |
31 | ----------------------------------------------------------------------------------------------------
32 | 14.查看可用的存储组列表: db2 select * from syscat.stogroups;
33 |
34 | 15.创建一个存储组: db2 create stogroup [stogropu_name] on [‘/path’];
35 |
36 | 16.创建存储组表空间: db2 create tablespace [tablespace_name] using stogroup [stogroup_name];
37 |
38 | 17.改变一个存储组: db2 alter stogroup [stogroup_name] add [‘/old_location’], [‘/new_location’];
39 |
40 | 18.存储组中删除文件夹路径: db2 alter stogroup [stogroup_name] drop [‘/path’];
41 |
42 | 19.重新调整表空间: db2 alter tablspace [tablspace_name] rebalance;
43 |
44 | 20.重命名存储组: db2 rename stogroup [old_stogroup_name] to [new_stogroup_name];
45 |
46 | 21.删除现有存储组: db2 drop stogorup [stogroup_name];
47 |
48 | ----------------------------------------------------------------------------------------------------
49 | 22.获得当前活动的模式：db2 get schema;
50 |
51 | 23.以目前的环境设置另一个模式: db2 set schema = [schema_name];
52 |
53 | 24.创建具有授权用户ID的新模式: db2 create schema [schema_name] authroization [inst_user];
54 |
55 | ----------------------------------------------------------------------------------------------------
56 | 25.创建表: db2 create table [schema_name].[table_name](column_name column_type ...) in [tablespace_name];
57 |
58 | 26.表详细信息列表: db2 select tabname, tabschema, tbspace from syscat.tables;
59 |
60 | 27.查看表的列和数据类型: db2 describe table [table_name];
61 |
62 | 28.创建具有隐藏列的表: db2 create table [table_name] (col1 datatype, col2 datatype implicitly hidden);
63 |
64 | 29.插入值到一个表: db2 insert into [table_name](col1, col2, ...) values(val1, val2, ...);
65 |
66 | 30.改变表列的类型: db2 alter table [table_name] alter column [col_name] set data type [data_type];
67 |
68 | 31.变更列名: db2 alter table [table_name] rename column [old_name] to [new_name];
69 |
70 | 32.删除表: db2 drop table [table_name];
71 |
72 | ----------------------------------------------------------------------------------------------------
73 | 33.创建数据库对象别名: db2 create alias [alias_name] for [table_name];
74 |
75 | 34.创建索引: db2 create unique index [index_name] on [table_name]([unique_column]) include ([column_name ...]);
76 |
77 | 35.删除索引: db2 drop index [index_name];
78 |
79 | ----------------------------------------------------------------------------------------------------
80 | 36.创建触发器的序列: db2 create sequence [seq_name];
81 |
82 | 37.创建触发器: db2 create trigger [trigger_name] no cascade before insert on
83 | [table_name] referencing new as [table_object] for each row set
84 | [table_object].[col_name] = nextval for [sequence_name];
85 |
86 | 38.删除触发器: db2 drop trigger [trigger_name];
87 |
88 | ----------------------------------------------------------------------------------------------------
89 | 39.创建视图: db2 create view [view_name] ([col_name1], ...) as select [col] ... from [table_name];
90 |
91 | 40.修改视图: db2 alter view [view_name] alter [col_name] add scope [table_or_view_name];
92 |
93 | 41.删除视图: db2 drop view [view_name];
94 |
95 | ----------------------------------------------------------------------------------------------------
96 | 42.创建一个新的角色: db2 create role [role_name];
97 |
98 | 43.授予的角色权限表: db2 grant select on table [table_name] to role [role_name];
99 |
100 | ----------------------------------------------------------------------------------------------------
101 | 44.SQL0407N 不允许对 NOT NULL 列 “TBSPACEID=4, TABLEID=1599, COLNO=0” 赋予空值。
102 | (1) 查找错误所在表： select * from syscat.tables where TBSPACEID=4 and TABLEID=1599;
103 | 结果表为：AppFmtAprIdMap.
104 | (2) 查找错误所在列： select * from syscat.columns where TABSCHEMA='EVM' and TABNAME='AppFmtAprIdMap' and COLNO=0;
105 | 结果列为：NewID.
106 |
107 | 45.执行存储过程：db2 -td@ -f + 存储过程路径.
108 | ```
109 |
--------------------------------------------------------------------------------
/Reading-Notes/EffectiveSTL/EffectiveSTL1.md:
--------------------------------------------------------------------------------
1 | 《Effective STL》 :books:
2 |
3 | > Scott Meyers 著 电子工业出版社
4 |
5 | ```c++
6 | 1.慎重选择容器类型。
7 | (1) 标准 STL 序列容器：vector、string、deque 和 list。
8 | (2) 标准 STL 关联容器：set、multiset、map 和 multimap。
9 | (3) 非标准序列容器：slist 和 rope。(slist：单向链表，rope：本质上是一个 “重型” string)
10 | (4) 非标准的关联容器：hash_set、hash_multiset、hash_map、hash_multimap。
11 | (5) vector 作为 string 的替代。
12 | (6) vector 作为标准关联容器的替代。
13 | (7) 几种标准的非 STL 容器：数组、bitset、valarray、stack、queue 和 priority_queue。
14 |
15 | 2.不要试图编写独立于容器类型的代码。
16 | 使用封装 (encapsulation) 技术从一种容器类型转到另一种。
17 | (1) class Widget { ... };
18 | typedef vector WidgetContainer;
19 | WidgetContainer wc;
20 | Widget bestWidget;
21 | ...
22 | WidgetContainer::iterator i = find(wc.begin(), wc.end(), bestWidget);
23 | (2) class Widget { ... };
24 | template
25 | SpecialAllocator { ... };
26 | typedef vector> WidgetContainer;
27 | WidgetContainer wc;
28 | Widget bestWidget;
29 | ...
30 | WidgetContainer::iterator i = find(wc.begin(), wc.end(), bestWidget);
31 |
32 | 3.确保容器中的对象拷贝正确而高效。
33 |
34 | 4.调用 empty 而不是检查 size() 是否为 0。
35 |
36 | 5.区间成员函数优先于与之对应的单元素成员函数。
37 | 给定 v1 和 v2 两个向量(vector)，使 v1 的内容和 v2 的后半部分相同的最简单操作?
38 | v1.assign(v2.begin() + v2.size() / 2, v2.end());
39 |
40 | 6.当心 C++ 编译器最烦人的分析机制。
41 | 一个存有整数 (int) 的文件，把这些整数复制到一个 list 中：
42 | ifstream dataFile("ints.dat");
43 | istream_iterator dataBegin(dataFile);
44 | istream_iterator dataEnd;
45 | list data(dataBegin, dataEnd);
46 |
47 | 7.如果容器中包含了通过 new 操作创建的指针，切记在容器对象析构前将指针 delete 掉。
48 | void doSomething() {
49 | typedef boost::shared_ptr SPW;
50 | vector vwp;
51 | for(int i=0; i
58 | void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp) {
59 | typedef typename iterator_traits::value_type ElementType;
60 | RandomAccessIterator i;
61 | ... // 使 i 指向基准元素
62 | ElementType pivotValue(*i); // 把基准元素复制到局部临时变量中
63 | ... // 做其余的排序工作
64 | }
65 |
66 | 9.慎重选择删除元素的方法。
67 | (1) 要删除容器中有特定值的所有对象：
68 | 如果容器是 vector、string 或 deque，则使用 erase-remove 习惯用法。
69 | Container c;
70 | c.erase(remove(c.begin(), c.end(), 1963), c.end());
71 | 如果容器是 list，则使用 list::remove。
72 | c.remove(1963);
73 | 如果容器是一个标准关联容器，则使用它的 erase 成员函数。
74 | c.erase(1963);
75 | (2) 要删除容器中满足特定判别式 (条件) 的所有对象：
76 | 如果容器是 vector、string 或 deque，则使用 erase-remove_if 习惯用法。
77 | bool badValue(int ); // 返回 x 是否为 "坏值"
78 | c.erase(remove_if(c.begin(), c.end(), badValue), c.end());
79 | 如果容器是 list，则使用 list::remove_if。
80 | c.remove_if(badValue);
81 | 如果容器是一个标准关联容器，则使用 remove_copy_if 和 swap，或者写一个循环来遍历容器中的元素，
82 | 记住当把迭代器传给 erase 时，要对它进行后缀递增。
83 | ① AssocContainer c; // 标准关联容器
84 | ...
85 | AssocContainer goodValues; // 保存不被删除的值的临时容器
86 | // 把不被删除的值从 c 复制到 goodValues 中
87 | remove_copy_if(c.begin(), c.end(), inserter(goodValues, goodValues.end()), badValue);
88 | c.swap(goodValues); // 交换 c 和 goodValues 的内容
89 | ② AssocContainer c;
90 | ...
91 | // for 循环的第三部分是空的，i 在下面递增
92 | for (AssocContainer::iterator i = c.begin(); i != c.end(); /*什么也不做*/ ) {
93 | if (badValue(*i)) c.erase(i++); // 对坏值，把当前的 i 传给 erase，递增 i 是副作用
94 | else ++i; // 对好值，则简单地递增 i
95 | }
96 | (3) 要在循环内部做某些 (除了删除对象之外的) 操作：
97 | 如果容器是一个标准序列容器，则写一个循环来遍历容器中的元素，记住每次调用 erase 时，要用它的返回值更新迭代器。
98 | 如果容器是一个标准关联容器，则写一个循环来遍历容器中的元素，记住当把迭代器传给 erase 时，要对迭代器做后缀递增。
99 |
100 | 10.了解分配子 (allocator) 的约定和限制。
101 | (1) 你的分配子是一个模版，模版参数 T 代表你为它分配内存的对象的类型。
102 | (2) 提供类型定义 pointer 和 reference，但是始终让 pointer 为 T*，reference 为 T&。
103 | (3) 千万别让你的分配子拥有随对象而不同的状态。通常，分配子不应该有非静态的数据成员。
104 | (4) 记住，传给分配子的 allocate 成员函数的是那些要求内存的对象的个数，而不是所需的字节数。
105 | 这些函数返回 T* 指针，即使尚未有 T 对象被构造出来。
106 | (5) 一定要提供嵌套的 rebind 模版，因为标准容器依赖该模版。
107 | template // 标准的分配子这样声明
108 | class allocator {
109 | public:
110 | template
111 | struct rebind {
112 | typedef allocator other;
113 | };
114 | ...
115 | };
116 | ```
117 |
--------------------------------------------------------------------------------
/Reading-Notes/SpringFramework/SpringFramework7.md:
--------------------------------------------------------------------------------
1 | 《Spring 2.5开发手册》 :books:
2 |
3 | ```java
4 | 31.操作被通知对象。
5 | 任何 AOP 代理都能够被转型为接口 org.springframework.aop.framework.Advised, 接口包括下面的方法：
6 | Advisor[] getAdvisors();
7 | void addAdvice(Advice advice) throws AopConfigException;
8 | void addAdvice(int pos, Advice advice) throws AopConfigException;
9 | void addAdvisor(Advisor advisor) throws AopConfigException;
10 | void addAdvisor(int pos, Advisor advisor) throws AopConfigException;
11 | int indexOf(Advisor advisor);
12 | boolean removeAdvisor(Advisor advisor) throws AopConfigException;
13 | void removeAdvisor(int index) throws AopConfigException;
14 | boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;
15 | boolean isFrozen();
16 |
17 | 32.自动代理 bean 定义。
18 | (1) BeanNameAutoProxyCreator 为名字匹配字符串或者通配符的 bean 自动创建 AOP 代理。
19 |
20 | jdk*,onlyJdk
21 |
22 |
23 | myInterceptor
24 |
25 |
26 |
27 |
28 | (2) DefaultAdvisorAutoProxyCreator 自动应用当前上下文中适当的通知器，
29 | 无需在自动代理通知器的 bean 定义中包括 bean 的名字。
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 | 33.使用元数据驱动的自动代理。
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 | 34.热交换目标源。
54 | org.springframework.aop.target.HotSwappableTargetSource 允许当调用者保持引用的时候，切换一个 AOP 代理的目标。
55 |
56 | HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean("swapper");
57 | Object oldTarget = swapper.swap(newTarget);
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 | 35.池化目标源。
68 | Spring 对 Jakarta Commons Pool 1.3 提供了开箱即用的支持，后者提供了一个相当有效的池化实现。
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 | 可以配置 Spring 来把任何被池化对象转型到 org.springframework.aop.target.PoolingConfig 接口。
81 |
82 |
83 |
84 |
85 |
86 | 36.原型目标源。
87 |
88 |
89 |
90 |
91 | 37.ThreadLocal 目标源。
92 |
93 |
94 |
95 | ```
96 |
--------------------------------------------------------------------------------
/Reading-Notes/EffectiveSTL/EffectiveSTL5.md:
--------------------------------------------------------------------------------
1 | 《Effective STL》 :books:
2 |
3 | > Scott Meyers 著 电子工业出版社
4 |
5 | ```c++
6 | 41.理解 ptr_fun、mem_fun 和 mem_fun_ref 的来由。
7 | for_each 算法：
8 | template
9 | Function for_each(InputIterator begin, InputIterator end, Function f) {
10 | while (begin != end) f(*begin++);
11 | }
12 | vector vw;
13 | for_each(vw.begin(), vw.end(), test); // 调用 #1
14 | // 该 mem_fun 声明针对不带参数的非 const 成员函数；C 是类，R 是所指向的成员函数返回类型
15 | template
16 | mem_fun_t
17 | mem_fun(R(C::*pmf)());
18 | list lpw;
19 | ...
20 | for_each(lpw.begin(), lpw.end(), mem_fun(&Widget::test)); // 现在可以通过编译了
21 | for_each(vw.begin(), vw.end(), ptr_fun(test)); // 与调用 #1 的行为一样
22 |
23 | 42.确保 less 与 operator< 具有相同的语义。
24 | Boost 库的智能指针 shared_ptr 的部分实现：
25 | namespace std { // 针对 boost::shared_ptr 的 std::less 特化
26 | template
27 | struct less>: public binary_function,
28 | boost::shared_ptr, bool> {
29 | bool operator() (const boost::shared_ptr& a, const boost::shared_ptr& b) const {
30 | return less()(a.get(), b.get()); // shared_ptr::get 返回 shared_ptr 对象的内置指针
31 | }
32 | };
33 | }
34 |
35 | 43.算法调用优先于手写的循环。
36 | (1) 效率：算法通常比程序员自己写的循环效率更高。
37 | (2) 正确性：自己写循环比使用算法更容易出错。
38 | (3) 可维护性：使用算法的代码通常比手写循环的代码更简洁明了。
39 | deque d;
40 | ...
41 | deque::iterator insertLocation = d.begin();
42 | for (size_t i = 0; i < numDoubles; ++i) {
43 | // 每次 insert 调用之后都更新 insertLocation 以便保持迭代器有效
44 | insertLocation = d.insert(insertLocation, data[i] + 41);
45 | ++insertLocation;
46 | }
47 |
48 | 44.容器的成员函数优先于同名的算法。
49 |
50 | 45.正确区分 count、find、binary_search、lower_bound、upper_bound 和 equal_range。
51 | 判断一个 list 容器中是否存在某个特定的 Widget 对象值。
52 | list lw; // list 容器
53 | Widget w; // 特定的 Widget 值
54 | if (find(lw.begin(), lw.end(), w) != lw.end()) {
55 | ...
56 | } else {
57 | ...
58 | }
59 | ```
60 | 
61 |
62 | ```c++
63 | 46.考虑使用函数对象而不是函数作为 STL 算法的参数。
64 | (1) 将一个集合中每个字符串对象的长度输出到 cout 中：
65 | struct StringSize: public unary_function {
66 | string::size_type operator()(const string& s) const {
67 | return s.size();
68 | }
69 | };
70 | transform(s.begin(), s.end(), ostream_iterator(cout, "\n"), StringSize());
71 | (2) 一个函数模版的实例化名称并不完全等同于一个函数的名称：
72 | template
73 | struct Average: public binary_function {
74 | FPType operator() (FPType val1, FPType val2) const {
75 | return average(val1, val2);
76 | }
77 | };
78 | template
79 | void writeAverages(InputIter1 begin1, InputIter1 end1, InputIter2 begin2, ostream& s) {
80 | transform(begin1, end1, begin2,
81 | ostream_iterator::value_type>(s, "\n"),
82 | Average::value_type>());
83 | }
84 |
85 | 47.避免产生 “直写型” (write-only) 的代码。
86 | 有一个 vector，删除其中所有值小于 x 的元素，但在最后一个其值不小于 y 的元素之前的所有元素都应该保留下来。
87 | vector v;
88 | int x, y;
89 | ...
90 | typedef vector::iterator VecIntIter;
91 | // 初始化 rangeBegin，使它指向 v 中大于等于 y 的最后一个元素之后的元素
92 | // 如果不存在这样的元素，则 rangeBegin 被初始化为 v.begin()
93 | // 如果最后这样的元素正好是 v 的最后一个元素，则 rangeBegin 被初始化为 v.end()
94 | VecIntIter rangeBegin = find_if(v.rbegin(), v.rend(), bind2nd(greater_equal(), y)).base();
95 | // 在从 rangeBegin 到 v.end() 的区间中，删除所有小于 x 的值
96 | v.erase(remove_if(rangeBegin, v.end(), bind2nd(less(), x)), v.end());
97 |
98 | 48.总是包含 (#include) 正确的头文件。
99 | (1) 几乎所有的标准 STL 容器都被声明在与之同名的头文件中，比如 vector 被声明在 中，list 被声明
100 | 在 中，等等。但是 和