- 博客(226)
- 资源 (514)
- 收藏
- 关注
RSS订阅原创 DriveMoE：端到端自动驾驶中视觉-语言-动作模型的混合专家革命
自动驾驶技术正经历从模块化范式向范式的重大转变。传统方法将感知、预测和规划分离为独立模块，虽然易于理解和调试，但存在误差累积和次优决策等问题。端到端自动驾驶旨在通过单一神经网络直接将传感器输入映射为控制指令，从而、减轻误差传播和实现全局目标优化。然而，现有端到端方法面临两个关键挑战：一是多视角视觉处理中的问题，系统需要同时处理多个摄像头视角，产生大量冗余信息；二是问题，罕见但关键的场景（如紧急避障）难以得到有效处理，因为统一模型往往会偏向更常见的场景。上海交通大学提出的DriveMoE框架创新性地将。
2025-09-13 12:45:00
755
原创 MoE meets In-Context Reinforcement Learning：混合专家模型与上下文强化学习的融合创新
MoE与ICRL的融合架构采用了多层次设计，将MoE的专家选择机制与ICRL的上下文学习能力有机结合。多头智能体门控网络经验回放池和多任务环境。
2025-09-13 07:00:00
523
原创 LoHoVLA：统一视觉-语言-动作模型的技术突破与设计精髓
LoHoVLA的架构基于大型预训练视觉语言模型（VLM）作为骨干网络，扩展了原有的语言生成头，使其能够同时生成语言子任务和离散动作标记。这种共享骨干使模型能够学习在规划和控制之间可泛化的表示。LoHoVLA的工作流程可以形式化地表示为：其中是时间步推断出的子任务，是生成的动作，是当前观察，是初始指令，是历史上下文。LoHoVLA代表了具身智能领域的一个重要发展方向：通过统一规划与控制的架构解决长期具身任务的挑战。
2025-09-12 12:45:00
856
原创 视觉-语言-动作指令调优：多模态模型从感知到操作的跨越
InstructVLA采用了一个统一的框架，使用单个视觉语言模型同时进行多模态推理和语言引导的潜在动作规划。该模型不仅生成文本输出以保留预训练VLM强大的语言理解和多模态推理能力，同时还生成用于下游操作的潜在动作表征。以下是InstructVLA的整体架构图：生成过程包含三个关键步骤：VLM进行异步自回归推理潜动作生成动作解码。
2025-09-12 07:00:00
842
原创 FedVLA：基于双门控混合专家的联邦视觉-语言-行动学习在机器人操纵中的创新设计
"""单个专家网络实现"""nn.GELU(),"""模态门控网络"""# 全局平均池化获取全局特征if x.dim() > 2: # 序列数据"""领域门控网络"""x = x.max(dim=1).values # 最大池化"""双门控混合专家系统"""# 创建模态专家])# 创建领域专家])# 创建门控网络# 其他参数# 模态门控计算# 领域门控计算# 计算专家输出# 组合两种专家输出。
2025-09-11 12:45:00
1438
原创 Conjugated Semantic Pool：利用预训练视觉-语言模型提升OOD检测的创新架构
在当今机器学习系统日益普及的背景下，已成为确保模型安全性和可靠性的关键技术。OOD检测的核心目标是识别那些与模型训练数据（分布内数据，In-Distribution, ID）在语义或统计特性上存在显著差异的样本，从而防止模型对这些未知样本做出过度自信的错误预测。这一挑战在关键安全领域尤为重要。以自动驾驶系统为例，当车辆遭遇训练数据中未曾见过的异常交通场景或特殊障碍物时，系统必须能够并将控制权交还给人类驾驶员，而不是继续做出可能危险的自主决策。
2025-09-11 07:00:00
691
原创 SiLU激活函数：深度学习中的革命性创新与架构设计深解
SiLU（Sigmoid Linear Unit）激活函数是一个结合了Sigmoid函数和线性乘法的创新设计。其数学表达式为：其中，是Sigmoid函数。这个设计看似简单，却蕴含着深刻的数学洞察力——它将线性变换与门控机制相结合，形成了一种自门控（Self-Gated）特性。SiLU函数可以看作是输入与其经过Sigmoid转换后的门控权重的乘积，这种设计让网络能够自适应地学习每个神经元的最佳激活策略。"""自定义SiLU激活函数的前向和反向传播可以针对特定硬件进行优化"""# 前向传播计算。
2025-09-10 12:45:00
872
原创 超越阶梯衰减：Poly学习率策略的架构创新与深度解析
Poly学习率策略作为深度学习优化领域的重要进展，通过其数学上的优雅性和实践中的有效性，已经成为许多state-of-the-art模型训练的标准配置。本文从理论基础、架构设计、实现细节到实际应用，全面探讨了Poly策略的各个方面。理论基础坚实：多项式衰减形式与优化理论的收敛性分析相符实践效果卓越：在多个领域和任务中 consistently 表现出色灵活性强：支持多种变体和扩展，适应不同场景需求易于实现：算法简洁，计算高效，易于集成到现有框架。
2025-09-10 07:00:00
1122
原创 ReAct框架：驱动通用任务自主智能体的革命性架构设计
人工智能正经历从到的根本性转变。在这一转变过程中，AI智能体（AI Agent）技术凭借其和成为了关键推动力。作为这一领域的突破性框架，ReAct（Reasoning+Acting）通过模仿人类“边做边想”的认知过程，使大型语言模型（LLM）获得了解决复杂现实问题的能力。传统AI系统通常局限于预训练知识库内的响应生成，面临和三大局限。这些系统无法获取实时信息，难以处理需要多步推理的任务，且缺乏与外部环境交互的能力。ReAct框架的提出解决了这些痛点，通过。
2025-09-09 12:45:00
1175
原创 稀疏混合专家（SMoE）架构：深度学习中的革命性设计
稀疏混合专家架构的核心思想是分工协作——将复杂的任务分解为多个子任务，由不同的“专家”处理，然后整合结果。每个专家是一个小型神经网络（通常是前馈层），SMoE层包含多个这样的专家，但每个输入只激活其中的一小部分。专家网络(Expert Networks)：多个独立的神经网络，每个专门处理特定类型的输入。门控机制(Gating Network/Router)：决定哪个专家处理输入token。聚合层(Combining Layer)：整合各个专家的输出。
2025-09-09 07:00:00
656
原创 超越编码器-解码器：Bahdanau注意力机制如何重塑序列到序列学习的格局
，但理解Bahdanau注意力这座“最初的桥梁”，对于任何希望深入理解现代神经网络架构，特别是注意力机制本质的研究者和工程师来说，都是一门不可或缺的必修课。它完美地诠释了如何从一个直观的idea出发，通过严谨的数学建模和巧妙的神经网络设计，最终推动整个领域向前迈进一大步的创新过程。它优雅地解决了原始Seq2Seq模型的信息瓶颈问题，通过引入可学习的、动态的软对齐机制，显著提升了对长序列建模的能力，尤其是在机器翻译任务上实现了当时最先进的性能。这显然是不现实的，对于长演讲，准确性会急剧下降。
2025-09-08 12:45:00
683
原创 SwiGLU激活函数：大模型背后的非线性变革与创新设计
SwiGLU的数学表达式如下：其中和是权重矩阵，和是偏置向量（在实际实现中有时会省略偏置项），表示逐元素乘法，表示beta参数为1的Swish函数。展开来看，SwiGLU也可以表示为：其中是Sigmoid函数。在一些实现中，输入会先分割成两部分，分别进行线性变换：其中和是分割后的两部分。
2025-09-08 07:00:00
1021
原创 华为OmniPlacement技术深度解析：突破超大规模MoE模型推理瓶颈的创新设计
混合专家模型（Mixture of Experts，MoE）作为大规模深度学习的前沿架构，通过稀疏激活模式成功地将模型参数规模推向了新的高度，同时保持了相对合理的计算成本。其核心思想是使用多个专门的“专家”子网络（通常是前馈神经网络）和一个门控机制，针对每个输入只激活部分专家进行处理。这种设计使得模型总参数量可以达到万亿级别，而实际计算成本只与激活的专家参数相关。问题。由于输入数据特性及门控网络的选择偏好，某些专家（称为“热专家”）会被频繁调用，而其他专家（称为“冷专家”）则相对闲置。
2025-09-06 12:45:00
1217
原创 阿里云通义MoE全局均衡技术：突破专家负载失衡的革新之道
混合专家模型（Mixture of Experts，MoE）是当前AI大模型领域最重要的架构创新之一，其核心思想是通过多个“专家”网络协同处理输入数据，并由门控网络动态选择或组合各个专家的输出，从而实现在不显著增加计算成本的情况下大幅扩大模型规模。MoE模型的工作原理类似于一个——面对不同问题，委员会主席（门控网络）会选择最相关的几位专家（ specialist networks）共同商议解决方案，而不是让所有成员都参与每个决策。
2025-09-06 07:00:00
1199
原创 HMoE：异构混合专家模型——大模型架构的革命性突破
以下是一个简化的HMoE实现，使用PyTorch框架构建。"""异构专家模块：不同规模的专家具有不同的参数量和容量参数：input_size: 输入维度hidden_size: 隐藏层维度（决定专家大小）output_size: 输出维度dropout_rate: Dropout概率"""# 专家规模由hidden_size决定，实现了异构性# 专家容量因子（动态调整）# 前向传播return x。
2025-09-05 12:45:00
790
原创 UltraMem架构：突破大模型推理效率的革命性设计
近年来，人工智能领域尤其是大规模语言模型（LLM）发展迅猛，模型参数数量从亿级迅猛增长到万亿级别，带来了前所未有的表达能力的同时，也。特别是在推理阶段，如何高效地利用模型参数成为制约其广泛应用的关键瓶颈。传统的密集模型（Dense Model）需要激活全部参数来处理每个输入，而混合专家模型（Mixture of Experts, MoE）虽然通过稀疏激活机制在一定程度上降低了计算量，但却面临着和字节跳动豆包大模型团队在ICLR 2025上提出的UltraMem架构，正是针对这一难题的突破性解决方案。
2025-09-05 07:00:00
792
原创 层归一化与批归一化：深度学习的稳定之锚与演进之路
批归一化（BN）和层归一化（LN）是深度学习发展史上的里程碑式创新。它们通过巧妙地标准化内部激活值，有效地解决了内部协变量偏移问题，充当了深度神经网络训练的“稳定器”和“加速器”。BN通过横向利用小批次信息进行标准化，在CV等领域和大批量训练中效果卓著，但其性能受制于Batch Size。LN通过纵向针对单个样本进行标准化，彻底摆脱了对Batch Size的依赖，在序列模型、小批量学习和强化学习中成为不可或缺的组件。它们的出现不仅解决了实际问题，更深刻地影响了神经网络架构的设计思路。
2025-09-04 12:45:00
812
原创 激活函数的演进与创新：深入解析ReLU与GELU的设计哲学与实践
特性ReLUGELU计算速度极快较快（有近似计算）稀疏性强，硬性中等，软性，概率性平滑性不平滑（0点不可导）平滑可导缓解梯度消失是（正区间）是（更全面）避免神经元死亡否是常见应用场景CNN、较早期的模型如何选择追求极致速度和简单性：ReLU及其变体（如Leaky ReLU）仍然是许多计算机视觉任务的可靠选择，特别是在资源受限的环境中。追求最佳性能和最先进模型：在自然语言处理、生成式模型（如GPT、Diffusion Model）以及任何基于Transformer的架构中，
2025-09-04 07:00:00
1225
原创 从自然语言到代码生成：大模型如何重塑软件开发范式
软件开发作为一门专业学科，经历了从机器语言到汇编语言，再到高级编程语言的漫长演进过程。每个阶段的进步都降低了编程的门槛，提高了开发效率。然而，直到最近，编程仍然需要掌握专门的计算机语言和复杂的系统知识。近年来，大型语言模型（LLM）的突破性进展正在引发软件开发范式的根本性变革。本文将从专业角度深入分析“人人都是开发者”这一观点，探讨自然语言编程的可行性，评估其技术基础与局限性，并展望未来软件开发的可能形态。
2025-09-03 12:45:00
860
原创 人工智能发展新范式：算法、算力与数据的三位一体驱动
为什么算法、算力和数据成为AI发展的关键驱动力，而不是其他因素如人才、资本或应用场景？这是因为这三要素直接决定了AI系统的能力上限和性能表现。
2025-09-03 07:00:00
1145
原创 机器学习的三位一体：模型、策略与算法——构建智能系统的核心基石
模型是机器学习三要素中的起点和基础。在数学上，一个模型就是一个从输入空间到输出空间的映射函数族或假设空间（Hypothesis Space）。其中，是映射函数，是模型的参数（Parameters），是参数空间。模型的作用就是提供一套完整的框架和假设，来描述输入数据与输出目标之间可能存在的关系。输入（Input）：即将被处理的数据，例如一张图片的像素值、一段音频的波形、一封邮件的内容。输出（Output）
2025-09-02 12:45:00
776
原创 大模型时代，机器学习基础是“屠龙技”还是“必修课”？
如果不理解偏差-方差权衡（Bias-Variance Tradeoff）、正则化等概念，你将无法理解为何需要“指令微调（Instruction Tuning）”和“人类反馈强化学习（RLHF）”来对齐模型行为，提升泛化到真实用户指令的能力。不理解它们的作用，你的调参就变成了“玄学炼丹”。比如，最新的Mamba（状态空间模型）的提出，就融合了控制论和经典系统模型的思想。四个维度，层层深入地为你揭开这层迷雾，论证为何在“傻瓜式”API的背后，深厚的机器学习根基反而成为了区分“调参侠”与“架构师”的关键鸿沟。
2025-09-02 07:00:00
1368
原创 ORPO：颠覆传统，偏好对齐的简约革命
要理解ORPO的创新性，我们必须首先回到问题的原点：我们为什么要对齐大模型？一个在大量文本上预训练好的基础模型（Base Model），就像一个博览群书但缺乏社会经验的天才。它拥有海量知识，却未必懂得如何安全、有帮助、符合人类价值观地与人交流。它可能会输出有害内容、虚构事实（幻觉）、或者给出冗长无用的回答。对齐，就是给这位天才进行“社会化”训练，使其行为与人类的偏好和意图保持一致。最初的对齐方法简单直接：监督微调（SFT）。我们收集大量高质量的“提问-回答”样本（例如，由人类专家编写），然后用这些数据对基础
2025-09-01 12:45:00
1696
原创 大模型偏好对齐强化学习技术：从PPO、GRPO到DPO的演进与创新
在大语言模型（LLM）飞速发展的今天，如何让这些“聪明”的模型真正理解并对齐人类偏好，已成为制约其实际应用的关键挑战。（RLHF）技术作为解决这一问题的核心手段，正经历着从传统方法到创新算法的快速演进。从早期的本文将深入解析多种旨在优化LLM对齐用户偏好的强化学习技术，从基础理论到实践应用，从传统方法到最新创新，全面剖析其架构设计、工作原理以及演进脉络。我们将通过生活化案例和代码示例，帮助读者理解这些复杂技术背后的直观原理，并探讨未来发展方向。
2025-09-01 07:00:00
794
原创 幻觉与模仿：深入剖析当前大语言模型为何未能跨越“理解”与“推理”的鸿沟
当被问到“猫的特征是什么？因为它被训练得要生成“流畅”、“相关”的文本，而“我不知道”或“这不存在”在它的训练数据（互联网）中并非高概率回应。本文将从架构原理、训练范式、能力边界等多个维度，系统地论证为何当前的大模型无法完成真正的“理解”与“推理”，并辅以生活化的案例，旨在拨开这层认知迷雾，为我们客观、理性地看待AI的现状与未来提供一份专业的注脚。它的“推理”是统计关联的影子，它的“理解”是符号操作的幻影。当模型不仅能读到“猫”，还能看到猫的图片、视频，听到它的叫声，它构建的内部表征将会更接近人类的概念。
2025-08-30 12:45:00
989
原创 大模型的白垩纪：巨兽统治与新生代的崛起
1750亿参数的GPT-3曾令世人震撼，而如今万亿参数模型已成常态，这种“暴力美学”背后却隐藏着AI发展的深层次危机。大模型正如白垩纪的恐龙，庞大而统治力十足，但新时代的哺乳动物正在暗处积蓄力量。在AI领域，这两年最忙的一项基础技术应该非大模型莫属。随着AI绘画、AI生成视频等能力不断刷新大众对AI技术边界的认知，站在AI创作家们背后的大模型的地位也跟着水涨船高。轰轰烈烈的“炼大模型”运动似乎来到了丰收时节。。这正如地质年代中的白垩纪——恐龙依旧统治着世界，但哺乳动物已经开始活跃。
2025-08-30 07:00:00
1059
原创 大模型的边界在哪里？探索AI巨兽的能力极限与未来挑战
大型语言模型的出现标志着自然语言处理领域的范式转变。基于Transformer架构的模型通过规模扩展，实现了前所未有的语言理解和生成能力。然而，随着模型规模的不断扩大，我们开始面临边际效益递减、计算成本飙升以及能力天花板等问题。为什么需要关注大模型的边界？首先，理解边界有助于我们合理规划研发方向，避免盲目追求参数规模；其次，明确边界可以帮助我们更好地将模型能力与实际问题匹配；最后，边界探索揭示了AI系统当前的根本限制，为未来突破指明方向。
2025-08-29 12:45:00
1151
原创 超越预训练：论大模型后训练（Post-Training）的架构必然性与创新设计
但有一个致命问题：如果只追求高奖励，模型可能会“钻空子”，生成一些毫无意义但能骗取高分的字符（例如一串“A++++”），或者退化到只输出那些绝对安全但无用的回答（例如“作为AI，我无法回答这个问题”）。未来的研究将聚焦于更高效的对齐方法，如直接偏好优化（DPO），它绕过了RM训练和复杂的PPO步骤，直接利用对比数据优化语言模型。它的架构设计，直接决定了模型最终的性能上限和安全性下限。SFT解决了“形”的问题，RLHF则要解决“神”的问题——对齐（Alignment），即让模型的价值观与人类偏好对齐。
2025-08-29 07:00:00
821
原创 幻象克星：大模型架构创新与对抗幻觉的深度博弈
大型语言模型，如GPT系列、LLaMA、PaLM等，通过在超大规模文本语料上进行自监督学习，获得了令人惊叹的生成与理解能力。其核心范式是基于概率的：模型根据给定的上文（Context），预测下一个最可能的词元（Token），并依此循环往复，直至生成完整序列。其生成概率可以形式化地表示为：其中，是时刻要生成的 token，是之前所有 token 的上文，是模型在时刻的隐藏状态，是输出投影矩阵。模型的训练目标是最大化训练数据的似然概率，即“模仿”所见过的文本分布，而非追求“事实真理”。
2025-08-28 12:45:00
1152
原创 解构问题解决的要素：强化学习教会了我们什么“数学”思维？
随着大语言模型（LLM）与RL的融合（如RLHF），这套数学语言正变得前所未有的重要，它正在教会机器如何更安全、更有效、更符合人类意图地解决问题。随后，时序差分（Temporal Difference, TD）学习被提出，它可以在不依赖环境模型的情况下直接从经验中学习（如著名的TD-Lambda算法）。：咖啡壶、咖啡豆、水壶等组成的整个系统，它会对你的动作做出反应（例如，你调细研磨度，可能会导致萃取过度）。：你调整策略，下次尝试“调细研磨度”（根据Q值，这个动作在“太酸”的状态下可能带来更高的长期回报）。
2025-08-28 07:00:00
1615
原创 Cantor：多模态思维链架构的创新设计与技术演进
然而，现实世界的信息本质上是多模态的——文本、图像、音频、视频等数据相互交织，传统单模态模型难以全面理解复杂场景。传统多模态模型通常独立编码不同模态（如用ResNet处理图像，BERT处理文本），导致模态间交互不足。：早期多模态模型（如CLIP、VisualBERT）采用简单的模态对齐（alignment）策略，但缺乏深层次的跨模态推理能力。，实现了跨模态的渐进式推理，显著提升了模型在复杂任务（如视觉问答、跨模态检索）上的表现。：传统的多模态融合方法（如交叉注意力）计算复杂度高，难以扩展到大规模应用。
2025-08-27 12:45:00
1178
原创 HRM：小型参数模型的隐性推理架构创新设计
成为主流后尤为明显。：大型模型需要昂贵的GPU/TPU集群进行训练和推理：大规模推理的碳足迹引发环境可持续性担忧传统小型模型(如TinyBERT、DistilBERT)主要通过实现模型压缩，公式表示为：其中为教师模型，为学生模型，为平衡系数。这种方法虽然有效，但存在明显的性能天花板。HRM架构的创新之处在于，它不再单纯追求参数量的减少，而是通过，使小型模型能够“隐性”地完成传统上需要大规模参数才能实现的复杂推理。
2025-08-27 07:00:00
862
原创 突破语言桎梏：Coconut框架如何通过潜在空间推理重塑大模型思维范式
在当今人工智能领域，大型语言模型(LLM)已成为推动技术进步的核心力量。从最初的GPT系列到如今的Llama、Gemini等模型，这些系统展现出了惊人的语言理解和生成能力。。这种限制不仅影响了推理效率，也制约了模型处理复杂问题的能力。Meta AI提出的Coconut框架(Chain of Continuous Thought)代表了一种突破性的解决方案。它通过让模型在连续潜在空间中进行推理，，实现了更高效、更灵活的推理过程。
2025-08-26 12:45:00
1146
原创 SynAdapt：基于连续思维链的自适应推理框架架构设计
思维链(Chain-of-Thought, CoT)技术自提出以来已成为增强大语言模型推理能力的关键方法。传统CoT采用离散化、分步式的推理模式，将复杂问题分解为一系列中间推理步骤。：离散步骤割裂了思维过程的连续性，导致信息在步骤间传递时出现损失。用信息论术语表示，步骤间信息损失可量化为：其中表示第步状态，表示连续上下文，为条件熵。：简单问题被迫经历与复杂问题相同的固定推理步骤，造成计算资源浪费。：静态推理策略无法根据问题难度动态调整，导致效率低下。
2025-08-26 07:00:00
1468
原创 大模型幻觉问题的深度解析与架构设计解决方案
大语言模型幻觉(Hallucination)指的是模型生成与输入无关、事实错误或逻辑不合理内容的现象。这种现象严重影响了模型的可信度和实用性，特别是在医疗、法律等高风险领域。：生成与已知事实不符的内容：生成与当前对话无关的内容：生成自相矛盾或不合逻辑的内容幻觉问题的核心在于模型本质上是在进行“模式匹配”而非“知识理解”。当面对训练数据中未充分覆盖的领域或问题时，模型倾向于基于统计规律“编造”内容而非承认无知。
2025-08-25 12:45:00
1213
原创 AI代码生成不等于研发提效：大模型时代的效率幻觉与技术债务危机
2025年，全球软件开发行业正经历一场静默的革命。GitHub Copilot用户突破1500万，阿里云内部40%的代码由AI生成，IDC预测AI编程工具市场渗透率将达60%。用友集团近期宣布接入通义灵码企业版后，AI代码生成占比已达37%，新员工学习时间节约超70%。表面上看，这些数据似乎印证了AI代码生成工具对研发效能的显著提升。
2025-08-25 07:00:00
1038
原创 大模型微调架构革命：阿里Swift与HuggingFace PEFT的技术解析与选型指南
在当今人工智能领域，大型语言模型(LLMs)和多模态大模型(MLLMs)已成为推动技术进步的核心引擎。然而，这些参数量动辄数十亿甚至上千亿的模型在带来强大能力的同时，也带来了前所未有的微调挑战。传统全参数微调方法需要更新模型所有参数，这不仅需要昂贵的计算资源(如多块高端GPU)，还会导致“灾难性遗忘”——模型在适应新任务时丢失原有的通用能力。据测算，全参数微调一个650亿参数的模型需要约1.3TB GPU显存，相当于16-20块NVIDIA A100 80GB GPU，单次训练成本超过15,000美元。
2025-08-24 12:45:00
1537
原创 QuanTA：量子启发的张量适应微调架构创新设计——大模型高效适配新范式
大型语言模型(LLM)的预训练-微调范式已成为现代人工智能系统的标准流程，然而传统微调方法面临着日益凸显的技术瓶颈。全参数微调(Full Fine-Tuning)虽然能够实现最佳性能，但其惊人的计算开销和存储需求使得该方法在实际应用中成本过高。以1750亿参数的GPT-3为例，全微调需要数百GB的GPU显存，远超大多数机构的算力预算。为应对这一挑战，参数高效微调技术(Parameter-Efficient Fine-Tuning，PEFT)应运而生。
2025-08-24 07:00:00
1225
原创 量子纠缠架构下的RAG与微调协同创新：确定性推理与自适应学习的统一范式
检索增强生成（Retrieval-Augmented Generation）技术自2020年由Lewis等人提出后，形成了以FAISS（Facebook AI Similarity Search）为代表的向量检索范式，其核心优势在于通过外部知识库保证生成内容的。而模型微调（Fine-Tuning）作为迁移学习的核心手段，通过调整模型参数实现。
2025-08-23 12:45:00
1572
原创 检索增强生成（RAG）与微调（Fine-tuning）的架构创新设计：技术演进、适用场景与实战指南
RAG与微调不是对立而是互补的技术路线。正如OpenAI技术架构师Lilian Weng所言：“RAG不是过渡方案，而是大模型落地的基础设施”。未来成功的AI架构将是微调的专业深度与RAG的灵活广度的有机融合，正如人类专家既需要扎实的专业训练，也离不开持续的学习更新。架构师行动指南评估知识更新频率和术语专业性从Naive RAG开始快速验证逐步引入Advanced RAG组件对核心领域知识进行参数高效微调建立持续的性能监控和迭代机制。
2025-08-23 07:00:00
1051
菜鸟取经·程序员面试（第1期）
1、本期内容
1.1 如何准备面试
1.2 “工作经验”栏里你填了些什么？
1.3 九步走帮你打造成功求职简历
1.4 专家点评简历三大误区
1.5 一流简历要避免的8 大错误
1.6 求职信不可犯的九大戒
1.7 找工作的20 条吐血经验
1.8 IT 面试：激情的重要性
1.9 用人单位常用的面试方式及面试问题
1.10 谈谈.Net 技术面试
1.11 谈谈技术面试
1.12 程序员面试时要注意细节
1.13 编程技术面试的五大要点
1.14 让面试失败的十个坏习惯
1.15 面试中要避免的肢体语言
1.16 面试后须做的五件事
1.17 5 种求职者面试难成功
1.18 7 大迹象预示面试成功
1.19 HR 对应届生的简历建议，请慎用英语！
1.20 HR 简历照片的重视程度只有5%
1.21 HR 经理的四种常用面试技法
1.22 被HR 快速否决的9 种求职者
1.23 人事经理30 秒看一份简历
1.24 大战微软面试
1.25 微软全球技术中心面试
1.26 一次谷歌面试趣事
1.27 Google 的面试经历
1.28 IBM 面试记
1.29 Infosys 面试经历
1.30 搜狐，百度和豆瓣的面试感受
1.31 百度面试归来，经验值又+1 了
1.32 淘宝面试记
1.33 淘宝面试失败总结
1.34 腾讯实习生笔试面试总结
1.35 曝光腾讯面试全记录
1.36 华为面试归来的感想
1.37 迅雷面试记
1.38 用友面试经历
1.39 TCL 面试经验分享
1.40 中移动总部面试经历
1.41 雀巢SMC 面试攻略
1.42 我在雀巢公司的面试
1.43 三赴上海易传媒—揭秘之旅
1.44 我在日企面试中落荒而逃
1.45 北京艾德思奇科技有限公司面试实录
1.46 30 岁面霸IT 男30 次面试失败经历
1.47 IT 外企那点儿事
1.48 《失业七个月，面试六十家公司》体会
1.49 面试笔试总结
1.50 今天面试开发人员，谈谈面试的体会
1.51 如何在面试中发现优秀程序员
2017-10-29
Nutch搜索引擎·Eclipse开发配置（第4期）
1.1 环境准备
1.1.1 本期引言
1.1.2 环境介绍
1.1.3 JDK 安装配置
1.1.4 ANT 安装配置
1.1.5 IvyDE 安装配置
1.1.5 Tomcat 安装配置
1.1.6 Cygwin 安装配置
1.2 Eclipse 开发
1.2.1 Solr 部署
1.2.2 Nutch 导入
1.2.3 Solr 与Nutch 结合
2017-10-29
Nutch搜索引擎·Nutch浅入分析（第5期）
1.1 Nutch 基本原理
1.1.1 Nutch 基本组成
1.1.2 Nutch 工作流程
1.2 Nutch 流程详解
1.2.1 Nutch 数据流程
1.2.2 Nutch 流程分析
2017-10-29
Nutch搜索引擎·Solr简介及安装（第2期）
1.1 Solr 简介
1.1.1 Solr 的特性
1.1.2 Solr 的目录结构
1.1.3 Solr 与Lucene 关系
1.2 Solr 安装
1.2.1 环境介绍
1.2.2 安装Solr
1.2.3 结合Nutch
2017-10-29
Nutch搜索引擎·Nutch简介及安装（第1期）
1.1 Nutch 简介
1.1.1 Nutch 的目标
1.1.2 Nutch 的优点
1.1.3 Nutch 与Lucene 关系
1.2 Nutch 安装
1.2.1 环境介绍
1.2.2 安装JDK
1.2.3 安装Tomcat
1.2.4 安装Nutch
2017-10-29
细细品味架构·Hadoop 2015技术发展与2016发展趋势（第10期）
1、本期内容
1.1 版权申明
1.2 内容之一
1.2.1 HDFS
1.2.2 YARN
1.2.3 2016 年发展趋势
1.2.4 现场答疑（Q&A）
1.3 内容之二
1.3.1 新API 接口
1.3.2 多个 Region 副本
1.3.3 Family 粒度的 Flush
1.3.4 RPC 读写队列分离
1.3.5 在线调整配置
1.3.6 社区的工作方向和趋势
1.3.7 现场答疑（Q & A）
2、知识扩展
2.1 Hadoop 十年解读与发展预测
2.1.1 年史篇
2.1.2 技术篇
2.1.3 产业篇
2.1.4 应用篇
2.1.5 展望篇
2.1.6 编者篇
2.2 Docker on YARN 在Hulu 的实现
2.2.1 设计动机
2.2.2 架构设计
2.2.3 编程模型
2.2.4 容错设计
2.2.5 应用实战
2.2.6 同类比较
2.2.7 展望未来
2017-10-29
Nutch搜索引擎（1-5期）
Nutch搜索引擎·Nutch简介及安装（第1期）
Nutch搜索引擎·Solr简介及安装（第2期）
Nutch搜索引擎·Nutch简单应用（第3期）
Nutch搜索引擎·Eclipse开发配置（第4期）
Nutch搜索引擎·Nutch浅入分析（第5期）
2017-10-29
九年双11互联网技术超级工程
新智能 1
阿里搜索技术，在AI路上走了多远？ 1
直击阿里新一代数据库技术：如何实现极致弹性能力？ 9
争分夺秒：阿里实时大数据技术全力助战双11 21
阿里小蜜这一年：从点到面的变迁 41
菜鸟仓配自动化UCS揭秘 62
阿里怎么发红包？自研智能权益系统首次公开 68
2017双11：开启智能全链路压测之路 78
智能写手：智能文本生成在2017双11的应用 85
浅谈分布式存储系统Pangu2.0：它让双11运维变得智能起来 100
新基础 118
双11稳定性负责人叔同讲述：九年双11的云化架构演进和升级 118
阿里双11网络技术揭秘：百万级物理和虚拟网络设备的智能化之路 134
从10%到40%：阿里巴巴混部技术权威详解 150
经历400多天打磨，HSF的架构和性能有哪些新突破？ 166
直击阿里容器技术Pouch 179
直击阿里双11神秘技术：PB级大规模文件分发系统“蜻蜓” 185
双11万亿流量下的分布式缓存 203
2017双11交易系统TMF2.0技术揭秘，实现全链路管理 214
新体验 221
一天造出10亿个淘宝首页，阿里工程师如何实现？ 221
双十一安全技术：目标检测在淘宝直播中的应用 238
持续迭代下的双11供应链体系最新架构及功能解读 244
七层流量清洗提供安全防护新方案 252
2017双11：区块链在天猫国际商品溯源中的应用 260
直击Weex在优酷双11猫晚直播的应用 270
如何把范冰冰“送”到你家？双11晚会“逆天”技术首次公开 281
2018-01-23
大数据之路：阿里巴巴大数据实践
第1章 总述1
第1篇 数据技术篇
第2章 日志采集8
2.1 浏览器的页面日志采集8
2.1.1 页面浏览日志采集流程9
2.1.2 页面交互日志采集14
2.1.3 页面日志的服务器端清洗和预处理15
2.2 无线客户端的日志采集16
2.2.1 页面事件17
2.2.2 控件点击及其他事件18
2.2.3 特殊场景19
2.2.4 H5 & Native日志统一20
2.2.5 设备标识22
2.2.6 日志传输23
2.3 日志采集的挑战24
2.3.1 典型场景24
2.3.2 大促保障26
第3章 数据同步29
3.1 数据同步基础29
3.1.1 直连同步30
3.1.2 数据文件同步30
3.1.3 数据库日志解析同步31
3.2 阿里数据仓库的同步方式35
3.2.1 批量数据同步35
3.2.2 实时数据同步37
3.3 数据同步遇到的问题与解决方案39
3.3.1 分库分表的处理39
3.3.2 高效同步和批量同步41
3.3.3 增量与全量同步的合并42
3.3.4 同步性能的处理43
3.3.5 数据漂移的处理45
第4章 离线数据开发48
4.1 数据开发平台48
4.1.1 统一计算平台49
4.1.2 统一开发平台53
4.2 任务调度系统58
4.2.1 背景58
4.2.2 介绍60
4.2.3 特点及应用65
第5章 实时技术68
5.1 简介69
5.2 流式技术架构71
5.2.1 数据采集72
5.2.2 数据处理74
5.2.3 数据存储78
5.2.4 数据服务80
5.3 流式数据模型80
5.3.1 数据分层80
5.3.2 多流关联83
5.3.3 维表使用84
5.4 大促挑战&保障86
5.4.1 大促特征86
5.4.2 大促保障88
第6章 数据服务91
6.1 服务架构演进91
6.1.1 DWSOA92
6.1.2 OpenAPI93
6.1.3 SmartDQ94
6.1.4 统一的数据服务层96
6.2 技术架构97
6.2.1 SmartDQ97
6.2.2 iPush100
6.2.3 Lego101
6.2.4 uTiming102
6.3 实践103
6.3.1 性能103
6.3.2 稳定性111
第7章 数据挖掘116
7.1 数据挖掘概述116
7.2 数据挖掘算法平台117
7.3 数据挖掘中台体系119
7.3.1 挖掘数据中台120
7.3.2 挖掘算法中台122
7.4 数据挖掘案例123
7.4.1 用户画像123
7.4.2 互联网反作弊125
第2篇 数据模型篇
第8章 大数据领域建模综述130
8.1 为什么需要数据建模130
8.2 关系数据库系统和数据仓库131
8.3 从OLTP和OLAP系统的区别看模型方法论的选择132
8.4 典型的数据仓库建模方法论132
8.4.1 ER模型132
8.4.2 维度模型133
8.4.3 Data Vault模型134
8.4.4 Anchor模型135
8.5 数据模型实践综述136
第9章 数据整合及管理体系138
9.1 概述138
9.1.1 定位及价值139
9.1.2 体系架构139
9.2 规范定义140
9.2.1 名词术语141
9.2.2 指标体系141
9.3 模型设计148
9.3.1 指导理论148
9.3.2 模型层次148
9.3.3 基本原则150
9.4 模型实施152
9.4.1 业界常用的模型实施过程152
9.4.2 OneData实施过程154
第10章 维度设计159
10.1 维度设计基础159
10.1.1 维度的基本概念159
10.1.2 维度的基本设计方法160
10.1.3 维度的层次结构162
10.1.4 规范化和反规范化163
10.1.5 一致性维度和交叉探查165
10.2 维度设计高级主题166
10.2.1 维度整合166
10.2.2 水平拆分169
10.2.3 垂直拆分170
10.2.4 历史归档171
10.3 维度变化172
10.3.1 缓慢变化维172
10.3.2 快照维表174
10.3.3 极限存储175
10.3.4 微型维度178
10.4 特殊维度180
10.4.1 递归层次180
10.4.2 行为维度184
10.4.3 多值维度18
10.4.4 多值属性187
10.4.5 杂项维度188
第11章 事实表设计190
11.1 事实表基础190
11.1.1 事实表特性190
11.1.2 事实表设计原则191
11.1.3 事实表设计方法193
11.2 事务事实表196
11.2.1 设计过程196
11.2.2 单事务事实表200
11.2.3 多事务事实表202
11.2.4 两种事实表对比206
11.2.5 父子事实的处理方式208
11.2.6 事实的设计准则209
11.3 周期快照事实表210
11.3.1 特性211
11.3.2 实例212
11.3.3 注意事项217
11.4 累积快照事实表218
11.4.1 设计过程218
11.4.2 特点221
11.4.3 特殊处理223
11.4.4 物理实现225
11.5 三种事实表的比较227
11.6 无事实的事实表228
11.7 聚集型事实表228
11.7.1 聚集的基本原则229
11.7.2 聚集的基本步骤229
11.7.3 阿里公共汇总层230
11.7.4 聚集补充说明234
第3篇 数据管理篇
第12章 元数据236
12.1 元数据概述236
12.1.1 元数据定义236
12.1.2 元数据价值237
12.1.3 统一元数据体系建设238
12.2 元数据应用239
12.2.1 Data Profile239
12.2.2 元数据门户241
12.2.3 应用链路分析241
12.2.4 数据建模242
12.2.5 驱动ETL开发243
第13章 计算管理245
13.1 系统优化245
13.1.1 HBO246
13.1.2 CBO249
13.2 任务优化256
13.2.1 Map倾斜257
13.2.2 Join倾斜261
13.2.3 Reduce倾斜269
第14章 存储和成本管理275
14.1 数据压缩275
14.2 数据重分布276
14.3 存储治理项优化277
14.4 生命周期管理278
14.4.1 生命周期管理策略278
14.4.2 通用的生命周期管理矩阵280
14.5 数据成本计量283
14.6 数据使用计费284
第15章 数据质量285
15.1 数据质量保障原则285
15.2 数据质量方法概述287
15.2.1 消费场景知晓289
15.2.2 数据加工过程卡点校验292
15.2.3 风险点监控295
15.2.4 质量衡量299
第4篇 数据应用篇
第16章 数据应用304
16.1 生意参谋305
16.1.1 背景概述305
16.1.2 功能架构与技术能力307
16.1.3 商家应用实践310
16.2 对内数据产品平台313
16.2.1 定位313
16.2.2 产品建设历程314
16.2.3 整体架构介绍317
附录A 本书插图索引320
2018-01-28
Hadoop集群（1-11期）
Hadoop集群·CentOS安装配置（第1期）
Hadoop集群·机器信息分布表（第2期）
Hadoop集群·VSFTP安装配置（第3期）
Hadoop集群·SecureCRT使用（第4期）
Hadoop集群·Hadoop安装配置（第5期）
Hadoop集群·JDK和SSH无密码配置（第5期副刊）
Hadoop集群·WordCount运行详解（第6期）
Hadoop集群·Eclipse开发环境设置（第7期）
Hadoop集群·HDFS初探之旅（第8期）
Hadoop集群·MapReduce初级案例（第9期）
Hadoop集群·MySQL关系数据库（第10期）
Hadoop集群·常用MySQL数据库命令（第10期副刊）
Hadoop集群·HBase简介及安装（第11期）
Hadoop集群·HBase之旅（第11期副刊）
2017-10-29
Spring Boot 2精髓-从构建小系统到架构分布式大系统（高清完整版）
第1章 Java EE简介
1．1 Java EE
1．1．1 Java EE架构
1．1．2 Java EE的缺点
1．2 Spring
1．2．1 Spring IoC容器和AOP
1．2．2 Spring的缺点
1．3 Spring Boot
1．4 Hello，Spring Boot
1．4．1 创建一个Maven工程
1．4．2 增加Web支持
1．4．3 Hello Spring Boot示例
1．4．4 使用热部署
1．4．5 添加REST支持
第2章 Spring Boot基础
2．1 检查Java环境与安装Java
2．2 安装和配置Maven
2．2．1 Maven介绍
2．2．2 安装Maven
2．2．3 设置Maven
2．2．4 使用IDE设置Maven
2．2．5 Maven的常用命令
2．3 Spring核心技术
2．3．1 Spring的历史
2．3．2 Spring容器介绍
2．3．3 Spring AOP介绍
第3章 MVC框架
3．1 集成MVC框架
3．1．1 引入依赖
3．1．2 Web应用目录结构
3．1．3 Java包名结构
3．2 使用Controller
3．3 URL映射到方法
3．3．1 @RequestMapping
3．3．2 URL路径匹配
3．3．3 HTTP method匹配
3．3．4 consumes和produces
3．3．5 params和header匹配
3．4 方法参数
3．4．1 PathVariable
3．4．2 Model＆ModelAndView
3．4．3 JavaBean接受HTTP参数
3．4．4 @RequsetBody接受JSON
3．4．5 MultipartFile
3．4．6 @ModelAttribute
3．4．7 @InitBinder
3．5 验证框架
3．5．1 JSR-303
3．5．2 MVC中使用@Validated
3．5．3 自定义校验
3．6 WebMvcConfigurer
3．6．1 拦截器
3．6．2 跨域访问
3．6．3 格式化
3．6．4 注册Controller
3．7 视图技术
3．7．1 使用Freemarker
3．7．2 使用Beetl
3．7．3 使用Jackson
3．7．4 Redirect和Forward
3．8 通用错误处理
3．9 @Service和@Transactional
3．9．1 声明一个Service类
3．9．2 事务管理
3．10 curl命令
第4章 视图技术
4．1 Beetl模板引擎
4．1．1 安装Beetl
4．1．2 设置定界符号和占位符
4．1．3 配置Beetl
4．1．4 groupTemplate
4．2 使用变量
4．2．1 全局变量
4．2．2 局部变量
4．2．3 共享变量
4．2．4 模板变量
4．3 表达式
4．3．1 计算表达式
4．3．2 逻辑表达式
4．4 控制语句
4．4．1 循环语句
4．4．2 条件语句
4．4．3 try catch
4．5 函数调用
4．6 格式化函数
4．7 直接调用Java
4．8 标签函数
4．9 HTML标签
4．10 安全输出
4．11 高级功能
4．11．1 配置Beetl
4．11．2 自定义函数
4．11．3 自定义格式化函数
4．11．4 自定义标签函数
4．11．5 自定义HTML标签
4．11．6 布局
4．11．7 AJAX局部渲染
4．12 脚本引擎
4．13 JSON技术
4．13．1 在Spring Boot中使用Jackson
4．13．2 自定义ObjectMapper
4．13．3 Jackson的三种使用方式
4．13．4 Jackson树遍历
4．13．5 对象绑定
4．13．6 流式操作
4．13．7 Jackson注解
4．13．8 集合的反序列化
4．14 MVC分离开发
4．14．1 集成WebSimulate
4．14．2 模拟JSON响应
4．14．3 模拟模板渲染
第5章 数据库访问
5．1 配置数据源
5．2 Spring JDBC Template
5．2．1 查询
5．2．2 修改
5．2．3 JdbcTemplate增强
5．3 BeetlSQL介绍
5．3．1 BeetlSQL功能概览
5．3．2 添加Maven依赖
5．3．3 配置BeetlSQL
5．3．4 SQLManager
5．3．5 使用SQL文件
5．3．6 Mapper
5．3．7 使用实体
5．4 SQLManager内置CRUD
5．4．1 内置的插入API
5．4．2 内置的更新（删除）API
5．4．3 内置的查询API
5．4．4 代码生成方法
5．5 使用sqlId
5．5．1 md文件命名
5．5．2 md文件构成
5．5．3 调用sqlId
5．5．4 翻页查询
5．5．5 TailBean
5．5．6 ORM查询
5．5．7 其他API
5．5．8 Mapper详解
5．6 BeetlSQL的其他功能
5．6．1 常用函数和标签
5．6．2 主键设置
5．6．3 BeetlSQL注解
5．6．4 NameConversion
5．6．5 锁
第6章 Spring Data JPA
6．1 集成Spring Data JPA
6．1．1 集成数据源
6．1．2 配置JPA支持
6．1．3 创建Entity
6．1．4 简化Entity
6．2 Repository
6．2．1 CrudRepository
6．2．2 PagingAndSortingRepository
6．2．3 JpaRepository
6．2．4 持久化Entity
6．2．5 Sort
6．2．6 Pageable和Page
6．2．7 基于方法名字查询
6．2．8 @Query查询
6．2．9 使用JPA Query
6．2．10 Example查询
第7章 Spring Boot配置
7．1 配置Spring Boot
7．1．1 服务器配置
7．1．2 使用其他Web服务器
7．1．3 配置启动信息
7．1．4 配置浏览器显示ico
7．2 日志配置
7．3 读取应用配置
7．3．1 Environment
7．3．2 @Value
7．3．3 @ConfigurationProperties
7．4 Spring Boot自动装配
7．4．1 @Configuration和@Bean
7．4．2 Bean条件装配
7．4．3 Class条件装配
7．4．4 Environment装配
7．4．5 其他条件装配
7．4．6 联合多个条件
7．4．7 Condition接口
7．4．8 制作Starter
第8章 部署Spring Boot应用
8．1 以jar文件运行
8．2 以war方式部署
8．3 多环境部署
8．4 @Profile注解
第9章 Testing单元测试
9．1 JUnit介绍
9．1．1 JUnit的相关概念
9．1．2 JUnit测试
9．1．3 Assert
9．1．4 Suite
9．2 Spring Boot单元测试
9．2．1 测试范围依赖
9．2．2 Spring Boot测试脚手架
9．2．3 测试Service
9．2．4 测试MVC
9．2．5 完成MVC请求模拟
9．2．6 比较MVC的返回结果
9．2．7 JSON比较
9．3 Mockito
9．3．1 模拟对象
9．3．2 模拟方法参数
9．3．3 模拟方法返回值
9．4 面向数据库应用的单元测试
9．4．1 @Sql
9．4．2 XLSUnit
9．4．3 XLSUnit的基本用法
第10章 REST
10．1 REST简介
10．1．1 REST风格的架构
10．1．2 使用“api”作为上下文
10．1．3 增加一个版本标识
10．1．4 标识资源
10．1．5 确定HTTP Method
10．1．6 确定HTTP Status
10．1．7 REST VS． WebService
10．2 Spring Boot集成REST
10．2．1 集成REST
10．2．2 @RestController
10．2．3 REST Client
10．3 Swagger UI
10．3．1 集成Swagger
10．3．2 Swagger规范
10．3．3 接口描述
10．3．4 查询参数描述
10．3．5 URI中的参数
10．3．6 HTTP头参数
10．3．7 表单参数
10．3．8 文件上传参数
10．3．9 整个请求体作为参数
10．4 模拟REST服务
第11章 MongoDB
11．1 安装MongoDB
11．2 使用shell
11．2．1 指定数据库
11．2．2 插入文档
11．2．3 查询文档
11．2．4 更新操作
11．2．5 删除操作
11．3 Spring Boot集成MongoDB
11．4 增删改查
11．4．1 增加API
11．4．2 根据主键查询API
11．4．3 查询API
11．4．4 修改API
11．4．5 删除API
11．4．6 使用MongoDatabase
11．4．7 打印日志
第12章 Redis
12．1 安装Redis
12．2 使用redis-cli
12．2．1 安全设置
12．2．2 基本操作
12．2．3 keys
12．2．4 Redis List
12．2．5 Redis Hash
12．2．6 Set
12．2．7 Pub/Sub
12．3 Spring Boot集成Redis
12．4 使用StringRedisTemplate
12．4．1 opsFor
12．4．2 绑定Key的操作
12．4．3 RedisConnection
12．4．4 Pub/Sub
12．5 序列化策略
12．5．1 默认序列化策略
12．5．2 自定义序列化策略
第13章 Elasticsearch
13．1 Elasticsearch介绍
13．1．1 安装Elasticsearch
13．1．2 Elasticsearch的基本概念
13．2 使用REST访问Elasticsearch
13．2．1 添加文档
13．2．2 根据主键查询
13．2．3 根据主键更新
13．2．4 根据主键删除
13．2．5 搜索文档
13．2．6 联合多个索引搜索
13．3 使用RestTemplate访问ES
13．3．1 创建Book
13．3．2 使用RestTemplate获取搜索结果
13．4 Spring Data Elastic
13．4．1 安装Spring Data
13．4．2 编写Entity
13．4．3 编写Dao
13．4．4 编写Controller
第14章 Cache
14．1 关于Cache
14．1．1 Cache的组件和概念
14．1．2 Cache的单体应用
14．1．3 使用专有的Cache服务器
14．1．4 使用一二级缓存服务器
14．2 Spring Boot Cache
14．3 注释驱动缓存
14．3．1 @Cacheable
14．3．2 Key生成器
14．3．3 @CachePut
14．3．4 @CacheEvict
14．3．5 @Caching
14．3．6 @CacheConfig
14．4 使用Redis Cache
14．4．1 集成Redis缓存
14．4．2 禁止缓存
14．4．3 定制缓存
14．5 Redis缓存原理
14．6 实现Redis两级缓存
14．6．1 实现TwoLevelCacheManager
14．6．2 创建RedisAndLocalCache
14．6．3 缓存同步说明
14．6．4 将代码组合在一起
第15章 Spring Session
15．1 水平扩展实现
15．2 Nginx的安装和配置
15．2．1 安装Nginx
15．2．2 配置Nginx
15．3 Spring Session
15．3．1 Spring Session介绍
15．3．2 使用Redis
15．3．3 Nginx+Redis
第16章 Spring Boot和ZooKeeper
16．1 ZooKeeper
16．1．1 ZooKeeper的数据结构
16．1．2 安装ZooKeeper
16．1．3 ZooKeeper的基本命令
16．1．4 领导选取演示
16．1．5 分布式锁演示
16．1．6 服务注册演示
16．2 Spring Boot集成ZooKeeper
16．2．1 集成Curator
16．2．2 Curator API
16．3 实现分布式锁
16．4 服务注册
16．4．1 通过ServiceDiscovery注册服务
16．4．2 获取服务
16．5 领导选取
第17章 监控Spring Boot应用
17．1 安装Acutator
17．2 HTTP跟踪
17．3 日志查看
17．4 线程栈信息
17．5 内存信息
17．6 查看URL映射
17．7 查看Spring容器管理的Bean
17．8 其他监控
17．9 编写自己的监控信息
17．9．1 编写HealthIndicator
17．9．2 自定义监控
2018-01-28
每天5分钟玩转OpenStack（高清完整版）
第一篇 预备知识
第 1 章 虚拟化 2
1.1 1型虚拟化 2
1.2 2型虚拟化 2
1.3 KVM 3
1.3.1 基本概念 3
1.3.2 KVM实操 4
1.4 KVM 虚拟化原理 11
1.4.1 CPU 虚拟化 11
1.4.2 内存虚拟化 12
1.4.3 存储虚拟化 13
1.5 网络虚拟化 19
1.5.1 Linux Bridge 19
1.5.2 VLAN 28
1.5.3 Linux Bridge + VLAN = 虚拟交换机 35
第 2 章 云 计 算 36
2.1 基本概念 36
2.2 云计算和 OpenStack 38
第二篇 OpenStack 核心
第 3 章 OpenStack 架构 41
3.1 Conceptual Architecture 41
3.2 Logical Architecture 42
第 4 章 搭建实验环境 45
4.1 部署拓扑 45
4.2 物理资源需求 46
4.3 网络规划 47
4.4 部署 DevStack 47
第 5 章 Identity Service——Keystone 55
5.1 概念 55
5.1.1 User 55
5.1.2 Credentials 57
5.1.3 Authentication 57
5.1.4 Token 57
5.1.5 Project 58
5.1.6 Service 59
5.1.7 Endpoint 60
5.1.8 Role 60
5.2 通过例子学习 62
5.2.1 第1步 登录 62
5.2.2 第2步 显示操作界面 62
5.2.3 第3步 显示image列表 63
5.2.4 Troubleshoot 64
第 6 章 Image Service——Glance 65
6.1 理解 Image 65
6.2 理解 Image Service 66
6.3 Glance 架构 66
6.4 Glance 操作 69
6.4.1 创建 image 70
6.4.2 删除 image 72
6.5 如何使用 OpenStack CLI 74
6.6 如何 Troubleshooting 77
第 7 章 Compute Service——Nova 79
7.1 Nova架构 80
7.1.1 架构概览 80
7.1.2 物理部署方案 82
7.1.3 从虚机创建流程看 nova-* 子服务如何协同工作 84
7.1.4 OpenStack 通用设计思路 85
7.2 Nova 组件详解 88
7.2.1 nova-api 88
7.2.2 nova-scheduler 90
7.2.3 nova-compute 97
7.2.4 nova-conductor 104
7.3 通过场景学习 Nova 105
7.3.1 看懂 OpenStack 日志 105
7.3.2 Launch 108
7.3.3 Shut Off 108
7.3.4 Start 112
7.3.5 Soft/Hard Reboot 114
7.3.6 Lock/Unlock 114
7.3.7 Terminate 115
7.3.8 Pause/Resume 116
7.3.9 Suspend/Resume 118
7.3.10 Rescue/Unrescue 119
7.3.11 Snapshot 122
7.3.12 Rebuild 125
7.3.13 Shelve 128
7.3.14 Unshelve 130
7.3.15 Migrate 133
7.3.16 Resize 139
7.3.17 Live Migrate 144
7.3.18 Evacuate 150
7.3.19 Instance 操作总结 154
7.4 小节 156
第 8 章 Block Storage Service ——Cinder 157
8.1 理解 Block Storage 157
8.2 理解 Block Storage Service 157
8.2.1 Cinder 架构 158
8.2.2 物理部署方案 159
8.2.3 从volume创建流程看cinder-*子服务如何协同工作 160
8.2.4 Cinder 的设计思想 161
8.2.5 Cinder组件详解 163
8.2.6 通过场景学习 Cinder 170
8.3 小节 220
第 9 章 Networking Service ——Neutron 221
9.1 Neutron 概述 221
9.1.1 Neutron 功能 221
9.1.2 Neutron 网络基本概念 222
9.2 Neutron 架构 224
9.2.1 物理部署方案 227
9.2.2 Neutron Server 228
9.2.3 Neutron 如何支持各种 network provider 229
9.2.4 ML2 Core Plugin 231
9.2.5 Service Plugin / Agent 234
9.2.6 小结 235
9.3 为Neutron 准备物理基础设施 237
9.3.1 1控制节点 + 1 计算节点的部署方案 237
9.3.2 配置多个网卡区分不同类型的网络数据 238
9.3.3 网络拓扑 239
9.3.4 安装和配置节点 240
9.4 Linux Bridge 实现 Neutron 网络 244
9.4.1 配置 linux-bridge mechanism driver 244
9.4.2 初始网络状态 245
9.4.3 了解Linux Bridge 环境中的各种网络设备 247
9.4.4 local network 248
9.4.5 flat network 262
9.4.6 DHCP 服务 270
9.4.7 vlan network 274
9.4.8 Routing 285
9.4.9 vxlan network 307
9.4.10 Securet Group 321
9.4.11 Firewall as a Service 328
9.4.12 Load Balancing as a Service 337
9.5 Open vSwitch 实现 Neutron 网络 358
9.5.1 网络拓扑 358
9.5.2 配置 openvswitch mechanism driver 359
9.5.3 初始网络状态 360
9.5.4 了解 Open vSwitch 环境中的各种网络设备 362
9.5.5 local network 362
9.5.6 flat network 377
9.5.7 vlan network 386
9.5.8 Routing 399
9.5.9 vxlan network 411
9.6 总结 421
写在最后 422
2018-01-28
架构探险：从零开始写分布式服务架构（高清完整版 + 全部源码）
第1章 常用的RPC框架 1
1.1 RPC框架原理 1
1.2 RMI介绍 2
1.2.1 原生RMI代码示例 3
1.2.2 RMI穿透防火墙 5
1.3 CXF/Axis2介绍 7
1.3.1 CXF介绍 7
1.3.2 Axis2介绍 14
1.4 Thrift介绍 21
1.4.1 Thrift工作原理介绍 23
1.4.2 Thrift IDL语法说明 26
1.4.3 基于Apache Thrift的Java版完整案例 28
1.4.4 基于Java注解的简化实现 36
1.5 gRPC介绍 42
1.5.1 protobuf3语法介绍 43
1.5.2 gRPC使用示例 45
1.6 HTTP Client介绍 53
1.6.1 构建HttpClient对象 54
1.6.2 构建URI对象 55
1.6.3 构建请求对象（HttpGet、HttpPost） 56
1.6.4 HttpClient发起调用及获取调用返回结果 56
1.7 实现自己的RPC框架 61
1.8 RPC框架与分布式服务框架的区别 68
1.9 本章小结 68
第2章 分布式服务框架总体架构与功能 69
2.1 面向服务的体系架构（SOA） 69
2.1.1 面向服务架构范式 69
2.1.2 服务拆分原则 71
2.2 分布式服务框架现实需求 72
2.3 分布式服务框架总体架构及所需的技术概述 72
2.4 本章小结 74
第3章 分布式服务框架序列化与反序列化实现 75
3.1 序列化原理及常用的序列化介绍 75
3.2 Java默认的序列化 77
3.3 XML序列化框架介绍 80
3.4 JSON序列化框架介绍 82
3.5 Hessian序列化框架介绍 87
3.6 protobuf序列化框架介绍 88
3.7 protostuff序列化框架介绍 93
3.8 Thrift序列化框架介绍 98
3.9 Avro序列化框架介绍 100
3.9.1 Avro介绍 100
3.9.2 Avro IDL语言介绍 101
3.9.3 Schema定义介绍 103
3.9.4 Maven配置及使用IDL与Schema自动生成代码 103
3.9.5 Avro序列化/反序列化实现 105
3.10 JBoss Marshalling序列化框架介绍 110
3.11 序列化框架的选型 112
3.12 实现自己的序列化工具引擎 113
3.13 本章小结 118
第4章 实现分布式服务框架服务的发布与引入 119
4.1 Spring Framework框架概述 119
4.1.1 Spring Framework介绍 119
4.1.2 Spring Framework周边生态项目介绍 121
4.2 FactoryBean的秘密 122
4.2.1 FactoryBean的作用及使用场景 123
4.2.2 FactoryBean实现原理及示例说明 124
4.3 Spring框架对于已有RPC框架集成的支持 127
4.3.1 Spring支持集成RPC框架介绍 127
4.3.2 基于RmiProxyFactoryBean 实现RMI与Spring的集成 128
4.3.3 基于HttpInvokerProxyFactoryBean实现HTTP Invoker与Spring的集成 131
4.3.4 基于HessianProxyFactoryBean实现Hessian与Spring的集成 133
4.4 实现自定义服务框架与Spring的集成 136
4.4.1 实现远程服务的发布 136
4.4.2 实现远程服务的引入 144
4.5 在Spring中定制自己的XML标签 150
4.6 本章小结 158
第5章 分布式服务框架注册中心 159
5.1 服务注册中心介绍 159
5.2 ZooKeeper实现服务的注册中心原理 161
5.2.1 ZooKeeper介绍 161
5.2.2 部署ZooKeeper 161
5.2.3 ZkClient使用介绍 164
5.2.4 ZooKeeper实现服务注册中心 173
5.3 集成ZooKeeper实现自己的服务注册与发现 175
5.3.1 服务注册中心服务提供方 175
5.3.2 服务注册中心服务消费方 176
5.3.3 服务注册中心实现 178
5.4 本章小结 189
第6章 分布式服务框架底层通信实现 190
6.1 Java I/O模型及I/O类库的进化 190
6.1.1 Linux下实现的I/O模型 190
6.1.2 Java语言实现的I/O模型 194
6.1.3 Java Classic I/O（Blocking I/O）介绍 194
6.1.4 Java Non-blocking I/O（NIO）介绍 211
6.1.5 NIO2及Asynchronous I/O介绍 233
6.2 Netty使用介绍 255
6.2.1 Netty开发入门 256
6.2.2 Netty粘包/半包问题解决 265
6.3 使用Netty构建服务框架底层通信 320
6.3.1 构建分布式服务框架Netty服务端 320
6.3.2 构建分布式服务框架服务调用端Netty客户端 330
6.4 本章小结 347
第7章 分布式服务框架软负载实现 348
7.1 软负载的实现原理 348
7.2 负载均衡常用算法 349
7.2.1 软负载随机算法实现 349
7.2.2 软负载加权随机算法实现 350
7.2.3 软负载轮询算法实现 351
7.2.4 软负载加权轮询算法实现 352
7.2.5 软负载源地址hash算法实现 354
7.3 实现自己的软负载机制 355
7.4 软负载在分布式服务框架中的应用 357
7.5 本章小结 361
第8章 分布式服务框架服务治理 362
8.1 服务治理介绍 362
8.2 服务治理的简单实现 364
8.2.1 服务分组路由实现 364
8.2.2 简单服务依赖关系分析实现 374
8.2.3 服务调用链路跟踪实现原理 380
8.3 本章小结 380
附录A 如何配置运行本书完成的分布式服务框架 381
2018-01-28
Spring boot 开发REST服务（全套视频以及源码）
1-1 导学.mp4
2-1 开发环境安装.mp4
2-2 代码结构介绍.mp4
2-3 Hello Spring Security.mp4
3-1 Restful简介.mp4
3-2 查询请求.mp4
3-3 用户详情请求.mp4
3-4 用户创建请求.mp4
3-5 修改和删除请求.mp4
3-6 服务异常处理.mp4
3-7 使用切片拦截REST服务.mp4
3-8 使用Filter和Interceptor拦截REST服务.mp4
3-9 使用REST方式处理文件服务.mp4
3-10 使用多线程提高REST服务性能.mp4
3-11 使用Swagger自动生成文档.mp4
3-12 使用WireMock伪造REST服务.mp4
4-1 简介.mp4
4-2 SpringSecurity基本原理.mp4
4-3 自定义用户认证逻辑.mp4
4-4 个性化用户认证流程（一）.mp4
4-5 个性化用户认证流程（二）.mp4
4-6 认证流程源码级详解.mp4
4-7 图片验证码.mp4
4-8 图片验证码重构.mp4
4-9 添加记住我功能.mp4
4-10 短信验证码接口开发.mp4
4-11 短信登录开发.mp4
4-12 短信登录配置及重构.mp4
4-13 小结.mp4
5-1 OAuth协议简介.mp4
5-2 SpringSocial简介.mp4
5-3 开发QQ登录（上）.mp4
5-4 开发QQ登录（中）.mp4
5-5 开发QQ登录（下）.mp4
5-6 处理注册逻辑.mp4
5-7 开发微信登录.mp4
5-8 绑定和解绑处理.mp4
5-9 单机Session管理.mp4
5-10 集群Session管理.mp4
5-11 退出登录.mp4
6-1 SpringSecurityOAuth简介.mp4
6-2 实现标准的OAuth服务提供商.mp4
6-3 SpringSecurityOAuth核心源码解析.mp4
6-4 重构用户名密码登录.mp4
6-5 重构短信登录.mp4
6-6 重构社交登录.mp4
6-7 重构注册逻辑.mp4
6-8 令牌配置.mp4
6-9 使用JWT替换默认令牌.mp4
6-10 基于JWT实现SSO单点登录1.mp4
6-11 基于JWT实现SSO单点登录2.mp4
7-1 SpringSecurity授权简介.mp4
7-2 SpringSecurity源码解析.mp4
7-3 权限表达式.mp4
7-4 基于数据库Rbac数据模型控制权限.mp4
8-1 课程总结.mp4
2018-01-24
从零开始学Storm（第2版）
第1章 Storm简介
1.1 什么是Storm 1
1.2 Storm的诞生 3
1.2.1 从Twitter说起 3
1.2.2 Twitter需要处理大批实时性要求高的大数据业务 3
1.2.3 Storm帮助Twitter解决实时海量大数据处理问题 4
1.3 Storm的成长 5
1.3.1 Storm正式开源 5
1.3.2 Apache接管并孵化Storm 5
1.3.3 Storm的核心技术和基本组成 6
1.3.4 Storm的项目小组 7
1.3.5 Storm的技术支持网站 10
1.4 Storm的优势 13
1.4.1 集成多种技术 13
1.4.2 简单的API 13
1.4.3 可扩展的 14
1.4.4 容错的 14
1.4.5 保证数据处理 14
1.4.6 可以使用任何语言 14
1.4.7 部署和操作简单 15
1.4.8 自由开源 15
1.5 Storm的应用现状和发展趋势 15
1.5.1 应用现状 16
1.5.2 发展趋势 18
1.6 如何学习Storm 20
1.7 本书的章节安排及学习建议 21
1.7.1 本书的章节安排 21
1.7.2 关于如何阅读本书的建议 22
1.8 本章小结 23
第 2 章 Storm的基本知识
2.1 概念 24
2.1.1 元组（Tuple） 24
2.1.2 流（Stream） 25
2.1.3 龙卷（Spout） 26
2.1.4 闪电（Bolt） 27
2.1.5 拓扑（Topology） 27
2.1.6 主控节点与工作节点 28
2.1.7 Nimbus进程与Supervisor进程 28
2.1.8 流分组（Stream grouping） 28
2.1.9 工作进程（Worker） 28
2.1.10 任务（Task） 28
2.1.11 执行器（Executor） 28
2.1.12 可靠性（Reliability） 29
2.2 Storm的配置 29
2.2.1 Storm的配置类型 29
2.2.2 defaults.yaml文件 30
2.2.3 storm.yaml文件 33
2.2.4 Config类 34
2.3 序列化（Serialization） 35
2.3.1 动态类型 36
2.3.2 自定义序列化 36
2.3.3 Java序列化 37
2.3.4 特定组件序列化注册 37
2.4 容错机制 37
2.4.1 Worker进程死亡 37
2.4.2 节点死亡 38
2.4.3 Nimbus或者Supervisor守护进程死亡 38
2.4.4 Nimbus是否是“单点故障” 38
2.5 可靠性机制——保证消息处理 38
2.5.1 消息被“完全处理”的含义 38
2.5.2 如果一个消息被完全处理或完全处理失败会发生什么 39
2.5.3 Storm如何保证可靠性 40
2.5.4 Storm如何实现可靠性 43
2.5.5 调节可靠性 44
2.6 消息传输机制 45
2.6.1 ZeroMQ 45
2.6.2 Netty 45
2.6.3 自定义消息通信机制 45
2.7 Storm的开发环境与生产环境 46
2.7.1 开发环境与本地模式 46
2.7.2 生产环境与远程模式 46
2.7.3 开发环境与生产环境的对比 47
2.8 Storm拓扑的并行度（parallelism） 48
2.8.1 工作进程、执行器和任务 48
2.8.2 配置拓扑的并行度 49
2.8.3 拓扑示例 50
2.8.4 如何改变运行中拓扑的并行度 51
2.9 Storm命令行客户端 52
2.10 Javadoc文档 56
2.11 本章小结 56
第 3 章 拓扑详解
3.1 什么是拓扑 57
3.2 TopologyBuilder 57
3.3 流分组 59
3.3.1 什么是流分组 59
3.3.2 不同的流分组方式 60
3.4 一个简单的拓扑 64
3.5 在本地模式下运行拓扑 67
3.6 在生产集群上运行拓扑 68
3.6.1 常见的配置 70
3.6.2 杀死拓扑 70
3.6.3 更新运行中的拓扑 71
3.6.4 监控拓扑 71
3.7 拓扑的常见模式 71
3.7.1 流连接（Stream Join） 71
3.7.2 批处理（Batching） 72
3.7.3 BasicBolt 72
3.7.4 内存中缓存与字段的组合 72
3.7.5 流的top N 72
3.7.6 高效保存近更新缓存对象的TimeCacheMap（已弃用） 74
3.7.7 分布式RPC的CoordinatedBolt与KeyedFairBolt 75
3.8 本地模式与StormSubmitter的对比 75
3.9 多语言协议（Multi-Language Protocol） 77
3.10 使用非JVM语言操作Storm 81
3.10.1 支持的非Java语言 81
3.10.2 对Storm使用非Java语言 81
3.10.3 实现非Java DSL的笔记 82
3.11 Hook 82
3.12 本章小结 83
第 4 章 组件详解
4.1 基本接口 84
4.1.1 IComponent接口 84
4.1.2 ISpout接口 85
4.1.3 IBolt接口 86
4.1.4 IRichSpout与IRichBolt接口 88
4.1.5 IBasicBolt接口 88
4.1.6 IStateSpout与IRichStateSpout接口 89
4.2 基本抽象类 90
4.2.1 BaseComponent抽象类 90
4.2.2 BaseRichSpout抽象类 90
4.2.3 BaseRichBolt抽象类 91
4.2.4 BaseBasicBolt抽象类 92
4.3 事务接口 92
4.3.1 IPartitionedTransactionalSpout 92
4.3.2 IOpaquePartitionedTransactionalSpout 94
4.3.3 ITransactionalSpout 95
4.3.4 ICommitterTransactionalSpout 96
4.3.5 IBatchBolt 97
4.4 组件之间的相互关系 97
4.5 本章小结 98
第 5 章 Spout详解
5.1 可靠的与不可靠的消息 99
5.2 Spout获取数据的方式 102
5.2.1 直接连接（Direct Connection） 102
5.2.2 消息队列（Enqueued Messages） 103
5.2.3 DRPC（分布式RPC） 104
5.3 常用的Spout 104
5.3.1 Kestrel作为Spout的数据源 104
5.3.2 AMQP作为Spout的数据源 104
5.3.3 JMS作为Spout的数据源 105
5.3.4 Redis作为Spout的数据源 105
5.3.5 beanstalkd作为Spout的数据源 105
5.4 学习编写Spout类 105
5.5 本章小结 106
第 6 章 Bolt详解
6.1 Bolt概述 107
6.2 可靠的与不可靠的Bolt 108
6.2.1 使用Anchoring机制实现可靠的Bolt 108
6.2.2 使用IBasicBolt接口实现自动确认 109
6.3 复合流与复合Anchoring 110
6.3.1 复合流 110
6.3.2 复合Anchoring 110
6.4 使用其他语言定义Bolt 111
6.5 学习编写Bolt类 111
6.5.1 可靠的Bolt 111
6.5.2 不可靠的Bolt 112
6.6 本章小结 113
第 7 章 ZooKeeper详解
7.1 ZooKeeper简介 114
7.2 ZooKeeper的下载和部署 114
7.2.1 ZooKeeper的下载 114
7.2.2 ZooKeeper的部署 115
7.3 ZooKeeper的配置 117
7.4 ZooKeeper的运行 119
7.5 ZooKeeper的本地模式实例 120
7.6 ZooKeeper的数据模型 121
7.6.1 ZNode 122
7.6.2 ZooKeeper中的时间 123
7.6.3 ZooKeeper的Stat结构 123
7.7 ZooKeeper的命令行操作范例 124
7.8 Storm在ZooKeeper中的目录结构 127
7.9 本章小结 128
第 8 章 基础软件的安装与使用
8.1 Linux的基本操作 129
8.1.1 环境变量 129
8.1.2 常用命令 130
8.2 JDK的下载与配置 134
8.2.1 Sun JDK的下载 134
8.2.2 在Linux下安装JDK 135
8.2.3 在Windows下安装JDK 136
8.3 GitHub托管项目的下载 141
8.4 Maven的下载与配置 143
8.4.1 Maven的下载 143
8.4.2 在Linux下部署Maven 144
8.4.3 在Windows下部署Maven 145
8.5 其他软件——Notepad++ 146
8.6 本章小结 147
第 9 章 Storm的安装与配置
9.1 Storm集群的安装步骤与准备工作 148
9.1.1 搭建ZooKeeper集群 148
9.1.2 安装Storm的本地依赖 148
9.1.3 下载并解压Storm发行版本 151
9.1.4 配置storm.yaml文件 153
9.1.5 启动Storm的守护进程 154
9.2 本地模式的Storm完整的配置命令 157
9.3 本章小结 159
第 10 章 Storm集群搭建实践
10.1 准备工作 160
10.1.1 概述 160
10.1.2 配置hosts文件 161
10.1.3 配置静态IP 161
10.1.4 集群SSH无密码 163
10.1.5 修改主机名 164
10.1.6 关闭防火墙 164
10.1.7 同步时间 164
10.1.8 安装JDK 165
10.2 ZooKeeper集群的搭建 166
10.2.1 部署**个节点 166
10.2.2 部署第i个节点 167
10.2.3 启动ZooKeeper集群 167
10.2.4 查看ZooKeeper状态 168
10.2.5 关闭ZooKeeper集群 168
10.2.6 清理ZooKeeper集群 168
10.3 Storm集群的搭建 168
10.3.1 安装Storm依赖（每个Storm节点） 168
10.3.2 部署**个节点 169
10.3.3 部署第i个节点 171
10.3.4 启动Storm守护进程 171
10.4 本章小结 172
第 11 章 准备Storm的开发环境
11.1 Storm的开发环境 173
11.1.1 什么是Storm的开发环境 173
11.1.2 如何管理Storm 173
11.1.3 如何提交拓扑到集群 176
11.2 Eclipse的下载与配置 176
11.2.1 Eclipse的下载 176
11.2.2 Eclipse的配置与运行 177
11.2.3 Eclipse插件的安装 178
11.3 使用Maven管理项目 180
11.3.1 Maven的下载与配置 180
11.3.2 配置pom.xml文件 180
11.3.3 运行Maven命令 182
11.4 使用Nexus搭建本地Maven私服 183
11.4.1 下载Nexus 183
11.4.2 运行Nexus 184
11.4.3 登录Nexus后台 184
11.4.4 配置Repositories 185
11.4.5 配置setting.xml文件 187
11.4.6 修改Eclipse的Maven插件的配置 189
11.5 使用SVN管理代码版本 189
11.5.1 在Windows下搭建SVN服务器 189
11.5.2 在Linux下搭建SVN服务器 191
11.5.3 安装SVN客户端 191
11.6 部署单节点的Storm集群 192
11.6.1 部署伪分布的ZooKeeper 192
11.6.2 部署伪分布的Storm集群 192
11.7 本章小结 194
第 12 章 开发自己的Storm应用
12.1 新建Maven项目 195
12.2 修改为适合Storm开发的项目 198
12.2.1 对包名进行分类管理 198
12.2.2 修改pom.xml文件 199
12.3 编写代码 201
12.3.1 编写Spout类 201
12.3.2 编写Bolt类 202
12.3.3 编写Topology类 203
12.4 本地测试运行 204
12.5 提交到Storm集群运行 205
12.5.1 使用Maven打包 205
12.5.2 提交jar包到集群 205
12.6 本章小结 206
第 13 章 storm-starter详解
13.1 storm-starter项目概述 207
13.2 storm-starter的下载 209
13.3 使用Maven进行管理 211
13.3.1 使用Maven打包storm-starter 211
13.3.2 使用Maven直接运行ExclamationTopology 211
13.3.3 使用Maven运行单元测试 211
13.4 在Eclipse中运行 212
13.4.1 新建Maven项目的方式 212
13.4.2 导入已存在的项目的方式 214
13.5 storm-starter的入门例子 214
13.5.1 ExclamationTopology 214
13.5.2 WordCountTopology 216
13.5.3 ReachTopology 219
13.6 storm-starter的其他例子 225
13.6.1 BasicDRPCTopology 225
13.6.2 ManualDRPC 226
13.6.3 PrintSampleStream 226
13.6.4 RollingTopWords 227
13.6.5 SkewedRollingTopWords 228
13.6.6 SingleJoinExample 229
13.6.7 TransactionalGlobalCount 230
13.6.8 TransactionalWords 230
13.6.9 WordCountTopologyNode 231
13.7 本章小结 232
第 14 章 研发与集群管理技巧
14.1 使用daemontools监控Storm进程 233
14.1.1 daemontools简介 233
14.1.2 安装daemontools 234
14.1.3 编写监控脚本 234
14.2 使用Monit监控Storm 236
14.2.1 Monit简介 236
14.2.2 安装Monit 237
14.2.3 配置Monit 238
14.2.4 启动Monit 240
14.2.5 获取Monit帮助信息 241
14.3 常用的集群操作命令 242
14.4 使用Storm的经验与建议 243
14.5 本章小结 244
第 15 章 DRPC详解
15.1 概述 245
15.2 DRPCTopologyBuilder 246
15.2.1 LinearDRPCTopologyBuilder 246
15.2.2 LinearDRPCTopologyBuilder提供的方法 246
15.2.3 LinearDRPCTopologyBuilder使用范例 248
15.2.4 LinearDRPCTopologyBuilder的工作原理 249
15.2.5 LinearDRPCTopologyBuilder目前已弃用 249
15.3 本地模式的DRPC 249
15.4 远程模式的DRPC 250
15.5 一个复杂的DRPC例子（计算reach值） 250
15.6 非线性DRPC 253
15.7 本章小结 253
第 16 章 事务拓扑详解
16.1 什么是事务拓扑 254
16.1.1 设计1 254
16.1.2 设计2 255
16.1.3 设计3（Storm的设计) 256
16.2 事务拓扑的设计细节 256
16.3 事务拓扑的实现细节 257
16.3.1 事务Spout的工作原理 257
16.3.2 “对于给定的事务id不能发射相同的Batch”的处理 258
16.3.3 更多的细节 260
16.4 事务拓扑API 260
16.4.1 Bolt 260
16.4.2 事务Spout 261
16.4.3 配置 262
16.5 TransactionalTopologyBuilder 262
16.5.1 TransactionalTopologyBuilder提供的方法 262
16.5.2 TransactionalTopologyBuilder类已弃用 266
16.6 一个简单的例子 266
16.7 本章小结 269
第 17 章 Trident详解
17.1 Trident概述 270
17.1.1 简单的例子——单词统计（TridentWordCount） 270
17.1.2 另一个例子——计算Reach值（TridentReach） 274
17.1.3 字段和元组 275
17.1.4 状态（State） 276
17.1.5 Trident拓扑的执行 277
17.2 Trident API 279
17.2.1 概述 279
17.2.2 本地分区操作 279
17.2.3 重新分区操作 283
17.2.4 聚合操作 284
17.2.5 流分组操作 284
17.2.6 合并与连接 285
17.3 Trident的状态 285
17.3.1 Trident状态分类 286
17.3.2 事务Spout（Transactional Spout） 286
17.3.3 不透明事务Spout（Opaque Transactional Spout） 288
17.3.4 非事务Spout（Non-transactional Spout） 289
17.3.5 Spout与State之间的联系 289
17.3.6 State API 290
17.3.7 persistentAggregate方法 294
17.3.8 实现 MapStates 294
17.4 Trident Spout 295
17.4.1 流水线（Pipelining） 296
17.4.2 Trident Spout的类型 296
17.5 本章小结 296
第 18 章 Storm的内部实现
18.1 文件系统分析 297
18.2 数据目录结构 298
18.2.1 Nimbus节点的目录结构 299
18.2.2 Supervisor节点的目录结构 299
18.3 代码库的结构 300
18.3.1 storm.thrift 301
18.3.2 Java接口 316
18.3.3 实现 316
18.4 拓扑的生命周期 318
18.4.1 启动拓扑 319
18.4.2 监控拓扑 321
18.4.3 杀死拓扑 321
18.5 Acking框架的实现 322
18.5.1 异或计算的基本原理 322
18.5.2 Acking框架的实现原理 322
18.5.3 Acker的execute方法 323
18.5.4 待定元组（pending tuple）和RotatingMap 323
18.6 Metric 324
18.7 本章小结 329
第 19 章 Storm相关的其他项目
19.1 JStorm项目 330
19.1.1 项目简介 330
19.1.2 下载与部署 331
19.1.3 源代码编译 332
19.2 storm-deploy项目 332
19.3 Storm与Kafka 333
19.3.1 Kafka简介 333
19.3.2 Kafka的安装 333
19.3.3 启动服务 334
19.3.4 测试运行 335
19.3.5 Storm与Kafka的项目 337
19.4 storm-kestrel项目 338
19.4.1 storm-kestrel项目简介 338
19.4.2 使用storm-kestrel项目 338
19.4.3 Kestrel服务器和队列 339
19.4.4 添加元素到kestrel 339
19.4.5 从Kestrel中移除元素 340
19.4.6 持续添加元素到Kestrel 341
19.4.7 使用KestrelSpout 342
19.4.8 执行 342
19.5 本章小结 343
第 20 章 企业应用案例
20.1 Storm席卷众多互联网企业 344
20.1.1 Storm的典型应用场景 344
20.1.2 Storm的三大基本应用 345
20.2 Storm在Twitter中的应用 345
20.2.1 Twitter公司简介 345
20.2.2 Storm帮助Twitter提升产品性能 346
20.2.3 MapR在Twitter中的应用简介 346
20.3 Storm在阿里巴巴集团的应用 348
20.3.1 阿里巴巴集团简介 348
20.3.2 Storm在阿里巴巴的应用 348
20.3.3 Storm在淘宝公司的应用 350
20.3.4 Storm在支付宝公司的应用 350
20.4 其他应用Storm的知名企业和项目 351
20.5 本章小结 367
参考资料 368
2017-12-05
细细品味架构（6-10期）
细细品味架构·大众点评实时监控系统CAT（第6期）
细细品味架构·酷狗音乐的大数据实践（第7期）
细细品味架构·360的分布式配置管理服务QConf（第8期）
细细品味架构·分布式Redis解决方案Codis（第9期）
细细品味架构·Hadoop 2015技术发展与2016发展趋势（第10期）
2017-10-29
菜鸟取经·程序员心声（第2期）
1、本期内容
1.1 态度决定方向，毅力成就行动
1.2 IT 草根的江湖路
1.3 人生感悟与心得
1.4 程序人生
1.5 也谈成功
1.6 一些个人感悟
1.7 最近的一些想法与大家分享
1.8 感悟、资产和幸福感
1.9 也谈人生
1.10 大道至简，职场上做人做事做管理
1.11 我的工作经历
1.12 老鸟对菜鸟的一些建议
1.13 程序员心底的小声音
1.14 职场人生
1.15 我们不仅是程序员
1.16 我应该遵守的简单条例
1.17 思想
2017-10-29
菜鸟取经·程序员管理（第3期）
1、本期内容
1.1 关于项目管理的一点体会
1.2 项目管理杂谈-我所期望的新人
1.3 项目管理杂谈-员工的积极性在哪里？
1.4 项目管理有感之一 沟通
1.5 关于项目管理的一点杂感
1.6 网站项目管理
1.7 项目管理者的尴尬
1.8 随便谈谈项目管理
1.9 项目管理中，最难管的是什么?
1.10 对项目管理的几点认识
1.11 2010 年下年终总结--项目管理篇
1.12 项目管理杂谈-走还是留，是个问题！
1.13 项目管理一些体会
1.14 项目管理经验教训总结
1.15 我的项目管理观点
2017-10-29
Introduction to Apache Flink
Chapter 1 Why Apache Flink?
Consequences of Not Doing Streaming Well
Goals for Processing Continuous Event Data
Evolution of Stream Processing Technologies
First Look at Apache Flink
Flink in Production
Where Flink Fits
Chapter 2 Stream-First Architecture
Traditional Architecture versus Streaming Architecture
Message Transport and Message Processing
The Transport Layer: Ideal Capabilities
Streaming Data for a Microservices Architecture
Beyond Real-Time Applications
Geo-Distributed Replication of Streams
Chapter 3 What Flink Does
Different Types of Correctness
Hierarchical Use Cases: Adopting Flink in Stages
Chapter 4 Handling Time
Counting with Batch and Lambda Architectures
Counting with Streaming Architecture
Notions of Time
Windows
Time Travel
Watermarks
A Real-World Example: Kappa Architecture at Ericsson
Chapter 5 Stateful Computation
Notions of Consistency
Flink Checkpoints: Guaranteeing Exactly Once
Savepoints: Versioning State
End-to-End Consistency and the Stream Processor as a Database
Flink Performance: the Yahoo! Streaming Benchmark
Conclusion
Chapter 6 Batch Is a Special Case of Streaming
Batch Processing Technology
Case Study: Flink as a Batch Processor
Appendix Additional Resources
Going Further with Apache Flink
Selected O’Reilly Publications by Ted Dunning and Ellen Friedman
2018-12-02
Scala程序设计（第2版）
第1章 零到六十：Scala简介 1
1.1 为什么选择Scala 1
1.1.1 富有魅力的Scala 2
1.1.2 关于Java 8 3
1.2 安装Scala 3
1.2.1 使用SBT 5
1.2.2 执行Scala命令行工具 6
1.2.3 在IDE中运行Scala REPL 8
1.3 使用Scala 8
1.4 并发 17
1.5 本章回顾与下一章提要 27
第2章 更简洁，更强大 28
2.1 分号 28
2.2 变量声明 29
2.3 Range 31
2.4 偏函数 32
2.5 方法声明 33
2.5.1 方法默认值和命名参数列表 33
2.5.2 方法具有多个参数列表 34
2.5.3 Future简介 35
2.5.4 嵌套方法的定义与递归 38
2.6 推断类型信息 40
2.7 保留字 44
2.8 字面量 46
2.8.1 整数字面量 46
2.8.2 浮点数字面量 47
2.8.3 布尔型字面量 48
2.8.4 字符字面量 48
2.8.5 字符串字面量 48
2.8.6 符号字面量 50
2.8.7 函数字面量 50
2.8.8 元组字面量 50
2.9 Option、Some 和None：避免使用null 52
2.10 封闭类的继承 53
2.11 用文件和名空间组织代码 54
2.12 导入类型及其成员 55
2.12.1 导入是相对的 56
2.12.2 包对象 57
2.13 抽象类型与参数化类型 57
2.14 本章回顾与下一章提要 59
第3章 要点详解 60
3.1 操作符重载? 60
3.2 无参数方法 63
3.3 优先级规则 64
3.4 领域特定语言 65
3.5 Scala中的if语句 66
3.6 Scala中的for推导式 67
3.6.1 for循环 67
3.6.2 生成器表达式 67
3.6.3 保护式：筛选元素 67
3.6.4 Yielding 68
3.6.5 扩展作用域与值定义 69
3.7 其他循环结构 70
3.7.1 Scala的while循环 71
3.7.2 Scala中的do-while循环 71
3.8 条件操作符 71
3.9 使用try、catch和final子句 72
3.10 名字调用和值调用 75
3.11 惰性赋值 78
3.12 枚举 79
3.13 可插入字符串 81
3.14 Trait：Scala语言的接口和“混入” 83
3.15 本章回顾与下一章提要 85
第4章 模式匹配 86
4.1 简单匹配 86
4.2 match中的值、变量和类型 87
4.3 序列的匹配 90
4.4 元组的匹配 94
4.5 case中的guard语句 94
4.6 case类的匹配 95
4.6.1 unapply方法 96
4.6.2 unapplySeq方法 100
4.7 可变参数列表的匹配 101
4.8 正则表达式的匹配 103
4.9 再谈case语句的变量绑定 104
4.10 再谈类型匹配 104
4.11 封闭继承层级与全覆盖匹配 105
4.12 模式匹配的其他用法 107
4.13 总结关于模式匹配的评价 111
4.14 本章回顾与下一章提要 111
第5章 隐式详解 112
5.1 隐式参数 112
5.2 隐式参数适用的场景 115
5.2.1 执行上下文 115
5.2.2 功能控制 115
5.2.3 限定可用实例 116
5.2.4 隐式证据 120
5.2.5 绕开类型擦除带来的限制 122
5.2.6 改善报错信息 124
5.2.7 虚类型 124
5.2.8 隐式参数遵循的规则 127
5.3 隐式转换 128
5.3.1 构建独有的字符串插入器 132
5.3.2 表达式问题 134
5.4 类型类模式 135
5.5 隐式所导致的技术问题 137
5.6 隐式解析规则 139
5.7 Scala内置的各种隐式 139
5.8 合理使用隐式 146
5.9 本章回顾与下一章提要 146
第6章 Scala函数式编程 147
6.1 什么是函数式编程 148
6.1.1 数学中的函数 148
6.1.2 不可变变量 149
6.2 Scala中的函数式编程 151
6.2.1 匿名函数、Lambda与闭包 152
6.2.2 内部与外部的纯粹性 154
6.3 递归 154
6.4 尾部调用和尾部调用优化 155
6.5 偏应用函数与偏函数 157
6.6 Curry化与函数的其他转换 158
6.7 函数式编程的数据结构 162
6.7.1 序列 162
6.7.2 映射表 166
6.7.3 集合 168
6.8 遍历、映射、过滤、折叠与归约 168
6.8.1 遍历 169
6.8.2 映射 170
6.8.3 扁平映射 172
6.8.4 过滤 173
6.8.5 折叠与归约 174
6.9 向左遍历与向右遍历 178
6.10 组合器：软件最佳组件抽象 183
6.11 关于复制 186
6.12 本章回顾与下一章提要 188
第7章 深入学习for推导式 189
7.1 内容回顾：for推导式组成元素 189
7.2 for推导式：内部机制 192
7.3 for推导式的转化规则 194
7.4 Option以及其他的一些容器类型 197
7.4.1 Option容器 197
7.4.2 Either：Option类型的逻辑扩展 200
7.4.3 Try类型 205
7.4.4 Scalaz提供的Validation类 206
7.5 本章回顾与下一章提要 209
第8章 Scala面向对象编程 210
8.1 类与对象初步 211
8.2 引用与值类型 213
8.3 价值类 214
8.4 父类 217
8.5 Scala的构造器 217
8.6 类的字段 221
8.6.1 统一访问原则 223
8.6.2 一元方法 224
8.7 验证输入 224
8.8 调用父类构造器（与良好的面向对象设计） 226
8.9 嵌套类型 230
8.10 本章回顾与下一章提要 232
第9章 特征 233
9.1 Java 8中的接口 233
9.2 混入trait 234
9.3 可堆叠的特征 238
9.4 构造trait 243
9.5 选择类还是trait 244
9.6 本章回顾与下一章提要 245
第10章 Scala对象系统（I） 246
10.1 参数化类型：继承转化 246
10.1.1 Hood下的函数 247
10.1.2 可变类型的变异 250
10.1.3 Scala和Java中的变异 252
10.2 Scala的类型层次结构 253
10.3 闲话Nothing（以及Null） 254
10.4 Product、case类和元组 258
10.5 Predef对象 260
10.5.1 隐式转换 260
10.5.2 类型定义 262
10.5.3 条件检查方法 263
10.5.4 输入输出方法 263
10.5.5 杂项方法 265
10.6 对象的相等 265
10.6.1 equals方法 266
10.6.2 == 和!=方法 266
10.6.3 eq 和ne方法 267
10.6.4 数组相等和sameElements方法 267
10.7 本章回顾与下一章提要 268
第11章 Scala对象系统（II） 269
11.1 覆写类成员和trait成员 269
11.2 尝试覆写final声明 272
11.3 覆写抽象方法和具体方法 272
11.4 覆写抽象字段和具体字段 274
11.5 覆写抽象类型 280
11.6 无须区分访问方法和字段：统一访问原则 280
11.7 对象层次结构的线性化算法 282
11.8 本章回顾与下一章提要 287
第12章 Scala集合库 288
12.1 通用、可变、不可变、并发以及并行集合 288
12.1.1 scala.collection包 289
12.1.2 collection.concurrent包 290
12.1.3 collection.convert包 291
12.1.4 collection.generic包 291
12.1.5 collection.immutable包 291
12.1.6 scala.collection.mutable包 292
12.1.7 scala.collection.parallel包 294
12.2 选择集合 295
12.3 集合库的设计惯例 296
12.3.1 Builder 296
12.3.2 CanBuildFrom 297
12.3.3 Like特征 298
12.4 值类型的特化 298
12.5 本章回顾与下一章提要 300
第13章 可见性规则 301
13.1 默认可见性：公有可见性 301
13.2 可见性关键字 302
13.3 Public可见性 303
13.4 Protected可见性 304
13.5 Private可见性 305
13.6 作用域内私有和作用域内受保护可见性 306
13.7 对可见性的想法 312
13.8 本章回顾与下一章提要 313
第14章 Scala类型系统（I） 314
14.1 参数化类型 315
14.1.1 变异标记 315
14.1.2 类型构造器 315
14.1.3 类型参数的名称 315
14.2 类型边界 315
14.2.1 类型边界上限 316
14.2.2 类型边界下限 316
14.3 上下文边界 320
14.4 视图边界 320
14.5 理解抽象类型 322
14.6 自类型标记 325
14.7 结构化类型 329
14.8 复合类型 332
14.9 存在类型 334
14.10 本章回顾与下一章提要 335
第15章 Scala类型系统（II） 336
15.1 路径相关类型 336
15.1.1 C.this 337
15.1.2 C.super 337
15.1.3 path.x 338
15.2 依赖方法类型 339
15.3 类型投影 340
15.4 值的类型 343
15.4.1 元组类型 343
15.4.2 函数类型 343
15.4.3 中缀类型 343
15.5 Higher-Kinded类型 344
15.6 类型Lambda 348
15.7 自递归类型：F-Bounded多态 350
15.8 本章回顾与下一章提要 351
第16章 高级函数式编程 352
16.1 代数数据类型 352
16.1.1 加法类型与乘法类型 352
16.1.2 代数数据类型的属性 354
16.1.3 代数数据类型的最后思考 355
16.2 范畴理论 355
16.2.1 关于范畴 356
16.2.2 Functor范畴 356
16.2.3 Monad范畴 360
16.2.4 Monad的重要性 362
16.3 本章回顾与下一章提要 363
第17章 并发工具 365
17.1 scala.sys.process包 365
17.2 Future类型 367
17.3 利用Actor模型构造稳固且可扩展的并发应用 371
17.4 Akka：为Scala设计的Actor系统 372
17.5 Pickling和Spores 383
17.6 反应式编程 384
17.7 本章回顾与下一章提要 385
第18章 Scala与大数据 386
18.1 大数据简史 386
18.2 用Scala改善MapReduce 387
18.3 超越MapReduce 392
18.4 数学范畴 393
18.5 Scala数据工具列表 394
18.6 本章回顾与下一章提要 394
第19章 Scala动态调用 396
19.1 一个较为激进的示例：Ruby on Rails框架中的ActiveRecord库 396
19.2 使用动态特征实现Scala 中的动态调用 397
19.3 关于DSL的一些思考 402
19.4 本章回顾与下一章提要 402
第20章 Scala的领域特定语言 403
20.1 DSL 示例：Scala中XML和JSON DSL 404
20.2 内部DSL 406
20.3 包含解析组合子的外部DSL 410
20.3.1 关于解析组合子 410
20.3.2 计算工资单的外部DSL 410
20.4 内部DSL与外部DSL：最后的思考 413
20.5 本章回顾与下一章提要 413
第21章 Scala工具和库 414
21.1 命令行工具 414
21.1.1 命令行工具：scalac 414
21.1.2 Scala命令行工具 418
21.1.3 scalap和javap命令行工具 421
21.1.4 scaladoc 命令行工具 422
21.1.5 fsc命令行工具 422
21.2 构建工具 422
21.2.1 SBT：Scala标准构建工具 423
21.2.2 其他构建工具 425
21.3 与IDE或文本编辑器集成 425
21.4 在Scala中应用测试驱动开发 426
21.5 第三方库 427
21.6 本章回顾与下一章提要 429
第22章 与Java的互操作 430
22.1 在Scala代码中使用Java名称 430
22.2 Java泛型与Scala泛型 430
22.3 JavaBean的性质 432
22.4 AnyVal类型与Java原生类型 433
22.5 Java代码中的Scala名称 433
22.6 本章回顾与下一章提要 434
第23章 应用程序设计 435
23.1 回顾之前的内容 435
23.2 注解 437
23.3 Trait即模块 441
23.4 设计模式 442
23.4.1 构造型模式 443
23.4.2 结构型模式 443
23.4.3 行为型模式 444
23.5 契约式设计带来更好的设计 446
23.6 帕特农神庙架构 448
23.7 本章回顾与下一章提要 453
第24章 元编程：宏与反射 454
24.1 用于理解类型的工具 455
24.2 运行时反射 455
24.2.1 类型反射 455
24.2.2 ClassTag、TypeTag与Manifest 457
24.3 Scala 的高级运行时反射API 458
24.4 宏 461
24.4.1 宏的示例：强制不变性 463
24.4.2 关于宏的最后思考 466
24.5 本章回顾与下一章提要 466
附录A 参考文献 468
作者简介 473
关于封面 473
2018-06-02
Apache Flink实践
案例篇
阿里巴巴为什么选择 Apache Flink? .................................................................. 1
Apache Flink 在滴滴出行的应用与实践............................................................11
字节跳动 Jstorm 到 Apache Flink 的迁移实践...............................................20
Apache Flink 在美团的实践与应用 ....................................................................32
Apache Flink 在唯品会的实践.............................................................................47
携程基于 Apache Flink 的实时特征平台...........................................................57
技术篇
一文了解 Apache Flink 核心技术 .......................................................................66
流计算框架 Flink 与 Storm 的性能对比.............................................................73
Spark VS Flink – 下一代大数据计算引擎之争，谁主沉浮? ......................95 5分钟从零构建第一个ApacheFlink应用.................................................. 109
Apache Flink 零基础实战教程:如何计算实时热门商品.......................... 114
Apache Flink SQL 概览 ..................................................................................... 124
Apache Flink 类型和序列化机制简介 ............................................................. 140
深度剖析阿里巴巴对 Apache Flink 的优化与改进 ....................................... 151
2018-11-30
逆流而上-阿里巴巴技术成长之路
第1章基础架构高可用
1.1明察秋毫，域名解析排查技巧
1.2智能定位，网络端到端静默丢包点迅速锁定
1.3灵活调度，对接运营商网络流量的容灾策略
1.4抽丝剥茧，深挖云盘挂起背后的真相
1.5存储的底线，SSD数据不一致
第2章中间件使用常见隐患与预防
2.1高并发“热点”缓存数据快速“退火”
2.2自我保护，让系统坚如磐石
2.3机房容灾，VIPServer软负载流量调度实例
2.4山洪暴发，高流量触发Tomcatbug引起集群崩溃
第3章数据库常见问题
3.1性能杀手，SQL执行计划
3.2波谲云诡，数据库延迟
3.3风暴来袭，AliSQL连接池调优
3.4防患于未然，ORM规约变更案例
3.5云数据库，SQL优化经典案例
第4章业务研发经典案例
4.1幂等控制，分布式锁超时情况和业务重试的并发
4.2另类解法，分布式一致性
4.3大道至简，从故障模型的边界状态切换到原始状态
4.4疑案追踪，JSON序列化不一致
4.5从现象到本质，不保证顺序的Class.getMethodsJVM实现
4.6破解超时迷局，浅析启动初期load飙高问题
4.7洞悉千丝万缕，浅谈JIT编译优化的误区
第5章运行管理域稳定性建设
5.1洞若观火，让故障无处遁形
5.2体系化思考，高效解决运营商问题
5.3以战养兵，以故障演练提升系统稳定性
2018-06-03
Oracle Application Express: Build Powerful Data-Centric Web Apps with APEX
Develop Robust Modern Web Applications with Oracle Application Express. Covers APEX 5.1.
Easily create data-reliant web applications that are reliable, scalable, dynamic, responsive, and secure using the detailed information contained in this Oracle Press guide. Oracle Application Express (APEX): Build Powerful Data-Centric Web Apps with APEX features step-by-step application development techniques, real-world coding examples, and best practices. You will find out how to work with the App Builder and Page Designer, use APEX themes (responsive and mobile included), templates and wizards, and design and deploy custom web apps. New and updated features in APEX 5.0/5.1 are thoroughly covered and explained.
• Understand APEX concepts and programming fundamentals
• Plan and control the development cycle, using HLD techniques
• Use APEX themes and templates, including Universal Theme
• Use APEX wizards to rapidly build forms and reports on database tables
• Build modern, dynamic, and interactive user interface using the Page Designer
• Increase user experience using Dynamic Actions (Ajax included)
• Build and utilize the new APEX 5.1 Interactive Grid
• Implement App Logic with APEX computations, validations, and processes
• Use (automatic) built-in and manual DML to manipulate your data
• Handle security at browser, application, and database levels
• Successfully deploy the developed APEX apps
2018-10-22
Go程序设计语言（中文高清版）
出版者的话
译者序
前言
第1章 入门 1
1.1 hello，world 1
1.2 命令行参数 3
1.3 找出重复行 6
1.4 GIF动画 10
1.5 获取一个URL 12
1.6 并发获取多个URL 13
1.7 一个Web服务器 14
1.8 其他内容 17
第2章 程序结构 20
2.1 名称 20
2.2 声明 21
2.3 变量 22
2.3.1 短变量声明 22
2.3.2 指针 23
2.3.3 new函数 25
2.3.4 变量的生命周期 26
2.4 赋值 27
2.4.1 多重赋值 27
2.4.2 可赋值性 28
2.5 类型声明 29
2.6 包和文件 30
2.6.1 导入 31
2.6.2 包初始化 33
2.7 作用域 34
第3章 基本数据 38
3.1 整数 38
3.2 浮点数 42
3.3 复数 45
3.4 布尔值 47
3.5 字符串 47
3.5.1 字符串字面量 49
3.5.2 Unicode 49
3.5.3 UTF-8 50
3.5.4 字符串和字节slice 53
3.5.5 字符串和数字的相互转换 56
3.6 常量 56
3.6.1 常量生成器iota 57
3.6.2 无类型常量 59
第4章 复合数据类型 61
4.1 数组 61
4.2 slice 63
4.2.1 append函数 66
4.2.2 slice就地修改 69
4.3 map 71
4.4 结构体 76
4.4.1 结构体字面量 78
4.4.2 结构体比较 80
4.4.3 结构体嵌套和匿名成员 80
4.5 JSON 82
4.6 文本和HTML模板 87
第5章 函数 92
5.1 函数声明 92
5.2 递归 93
5.3 多返回值 96
5.4 错误 98
5.4.1 错误处理策略 99
5.4.2 文件结束标识 101
5.5 函数变量 102
5.6 匿名函数 104
5.7 变长函数 110
5.8 延迟函数调用 111
5.9 宕机 115
5.10 恢复 118
第6章 方法 120
6.1 方法声明 120
6.2 指针接收者的方法 122
6.3 通过结构体内嵌组成类型 124
6.4 方法变量与表达式 127
6.5 示例：位向量 128
6.6 封装 130
第7章 接口 133
7.1 接口即约定 133
7.2 接口类型 135
7.3 实现接口 136
7.4 使用flag.Value来解析参数 139
7.5 接口值 141
7.6 使用sort.Interface来排序 144
7.7 http.Handler接口 148
7.8 error接口 152
7.9 示例：表达式求值器 154
7.10 类型断言 160
7.11 使用类型断言来识别错误 161
7.12 通过接口类型断言来查询特性 162
7.13 类型分支 164
7.14 示例：基于标记的XML解析 166
7.15 一些建议 168
第8章 goroutine和通道 170
8.1 goroutine 170
8.2 示例：并发时钟服务器 171
8.3 示例：并发回声服务器 174
8.4 通道 176
8.4.1 无缓冲通道 177
8.4.2 管道 178
8.4.3 单向通道类型 180
8.4.4 缓冲通道 181
8.5 并行循环 183
8.6 示例：并发的Web爬虫 187
8.7 使用select多路复用 190
8.8 示例：并发目录遍历 192
8.9 取消 195
8.10 示例：聊天服务器 198
第9章 使用共享变量实现并发 201
9.1 竞态 201
9.2 互斥锁：sync.Mutex 205
9.3 读写互斥锁：sync.RWMutex 208
9.4 内存同步 208
9.5 延迟初始化：sync.Once 210
9.6 竞态检测器 212
9.7 示例：并发非阻塞缓存 212
9.8 goroutine与线程 218
9.8.1 可增长的栈 219
9.8.2 goroutine调度 219
9.8.3 GOMAXPROCS 219
9.8.4 goroutine没有标识 220
第10章 包和go工具 221
10.1 引言 221
10.2 导入路径 221
10.3 包的声明 222
10.4 导入声明 223
10.5 空导入 223
10.6 包及其命名 225
10.7 go工具 226
10.7.1 工作空间的组织 227
10.7.2 包的下载 228
10.7.3 包的构建 229
10.7.4 包的文档化 231
10.7.5 内部包 232
10.7.6 包的查询 233
第11章 测试 235
11.1 go test工具 235
11.2 Test函数 236
11.2.1 随机测试 239
11.2.2 测试命令 240
11.2.3 白盒测试 242
11.2.4 外部测试包 245
11.2.5 编写有效测试 246
11.2.6 避免脆弱的测试 247
11.3 覆盖率 248
11.4 Benchmark函数 250
11.5 性能剖析 252
11.6 Example函数 254
第12章 反射 256
12.1 为什么使用反射 256
12.2 reflect.Type和reflect.Value 257
12.3 Display：一个递归的值显示器 259
12.4 示例：编码S表达式 263
12.5 使用reflect.Value来设置值 266
12.6 示例：解码S表达式 268
12.7 访问结构体字段标签 271
12.8 显示类型的方法 273
12.9 注意事项 274
第13章 低级编程 276
13.1 unsafe.Sizeof、Alignof 和Offsetof 276
13.2 unsafe.Pointer 278
13.3 示例：深度相等 280
13.4 使用cgo调用C代码 282
13.5 关于安全的注意事项 286
2018-06-03
每天5分钟玩转Docker容器技术 完整中文版 清晰版书籍
目 录
第一篇 启 程
第1章 鸟瞰容器生态系统 3
1.1 容器生态系统 3
1.2 本教程覆盖的知识范围 10
1.3 准备实验环境 10
1.3.1 环境选择 10
1.3.2 安装 Docker 10
1.4 运行第一个容器 11
1.5 小结 12
第二篇 容器技术
第2章 容器核心知识概述 15
2.1 What —— 什么是容器 15
2.2 Why —— 为什么需要容器 16
2.2.1 容器解决的问题 16
2.2.2 Docker 的特性 20
2.2.3 容器的优势 20
2.3 How —— 容器是如何工作的 21
2.4 小结 24
第3章 Docker 镜像 26
3.1 镜像的内部结构 26
3.1.1 hello-world —— 最小的镜像 26
3.1.2 base 镜像 27
3.1.3 镜像的分层结构 30
3.2 构建镜像 32
3.2.1 docker commit 32
3.2.2 Dockerfile 34
3.3 RUN vs CMD vs ENTRYPOINT 42
3.3.1 Shell 和 Exec 格式 42
3.3.2 RUN 44
3.3.3 CMD 44
3.3.4 ENTRYPOINT 45
3.3.5 最佳实践 46
3.4 分发镜像 46
3.4.1 为镜像命名 46
3.4.2 使用公共 Registry 49
3.4.3 搭建本地 Registry 51
3.5 小结 52
第4章 Docker 容器 55
4.1 运行容器 55
4.1.1 让容器长期运行 56
4.1.2 两种进入容器的方法 57
4.1.3 运行容器的最佳实践 59
4.1.4 容器运行小结 59
4.2 stop/start/restart 容器 60
4.3 pause / unpause 容器 61
4.4 删除容器 61
4.5 State Machine 62
4.6 资源限制 65
4.6.1 内存限额 65
4.6.2 CPU 限额 66
4.6.3 Block IO 带宽限额 68
4.7 实现容器的底层技术 69
4.7.1 cgroup 70
4.7.2 namespace 70
4.8 小结 72
第5章 Docker 网络 74
5.1 none 网络 74
5.2 host 网络 75
5.3 bridge 网络 76
5.4 user-defined 网络 78
5.5 容器间通信 84
5.5.1 IP通信 84
5.5.2 Docker DNS Server 85
5.5.3 joined 容器 85
5.6 将容器与外部世界连接 87
5.6.1 容器访问外部世界 87
5.6.2 外部世界访问容器 90
5.7 小结 91
第6章 Docker 存储 92
6.1 storage driver 92
6.2 Data Volume 94
6.2.1 bind mount 94
6.2.2 docker managed volume 96
6.3 数据共享 99
6.3.1 容器与 host 共享数据 99
6.3.2 容器之间共享数据 99
6.4 volume container 100
6.5 data-packed volume container 102
6.6 Data Volume 生命周期管理 103
6.6.1 备份 104
6.6.2 恢复 104
6.6.3 迁移 104
6.6.4 销毁 104
6.7 小结 105
第三篇 容器进阶知识
第7章 多主机管理 109
7.1 实验环境描述 110
7.2 安装 Docker Machine 111
7.3 创建 Machine 112
7.4 管理Machine 114
第8章 容器网络 117
8.1 libnetwork & CNM 117
8.2 overlay 119
8.2.1 实验环境描述 120
8.2.2 创建overlay网络 121
8.2.3 在overlay中运行容器 122
8.2.4 overlay 网络连通性 124
8.2.5 overlay 网络隔离 126
8.2.6 overlay IPAM 127
8.3 macvlan 127
8.3.1 准备实验环境 127
8.3.2 创建 macvlan 网络 128
8.3.3 macvlan 网络结构分析 130
8.3.4 用 sub-interface 实现多 macvlan 网络 131
8.3.5 macvlan 网络间的隔离和连通 132
8.4 flannel 136
8.4.1 实验环境描述 137
8.4.2 安装配置 etcd 137
8.4.3 build flannel 138
8.4.4 将 flannel 网络的配置信息保存到 etcd 139
8.4.5 启动 flannel 139
8.4.6 配置 Docker 连接 flannel 141
8.4.7 将容器连接到 flannel 网络 143
8.4.8 flannel 网络连通性 144
8.4.9 flannel 网络隔离 146
8.4.10 flannel 与外网连通性 146
8.4.11 host-gw backend 146
8.5 weave 148
8.5.1 实验环境描述 148
8.5.2 安装部署 weave 149
8.5.3 在host1中启动weave 149
8.5.4 在 host1 中启动容器 150
8.5.5 在host2中启动weave并运行容器 153
8.5.6 weave 网络连通性 154
8.5.7 weave 网络隔离 155
8.5.8 weave 与外网的连通性 156
8.5.9 IPAM 158
8.6 calico 158
8.6.1 实验环境描述 159
8.6.2 启动 etcd 159
8.6.3 部署 calico 160
8.6.4 创建calico网络 161
8.6.5 在 calico 中运行容器 161
8.6.6 calico 默认连通性 164
8.6.7 calico policy 167
8.6.8 calico IPAM 169
8.7 比较各种网络方案 170
8.7.1 网络模型 171
8.7.2 Distributed Store 171
8.7.3 IPAM 171
8.7.4 连通与隔离 172
8.7.5 性能 172
第9章 容器监控 173
9.1 Docker自带的监控子命令 173
9.1.1 ps 173
9.1.2 top 174
9.1.3 stats 175
9.2 sysdig 175
9.3 Weave Scope 179
9.3.1 安装 179
9.3.2 容器监控 181
9.3.3 监控 host 184
9.3.4 多主机监控 186
9.4 cAdvisor 189
9.4.1 监控 Docker Host 189
9.4.2 监控容器 191
9.5 Prometheus 194
9.5.1 架构 194
9.5.2 多维数据模型 195
9.5.3 实践 196
9.6 比较不同的监控工具 204
9.7 几点建议 205
第10章 日志管理 207
10.1 Docker logs 207
10.2 Docker logging driver 209
10.3 ELK 211
10.3.1 日志处理流程 211
10.3.2 安装 ELK 套件 212
10.3.3 Filebeat 214
10.3.4 管理日志 216
10.4 Fluentd 220
10.4.1 安装 Fluentd 221
10.4.2 重新配置 Filebeat 221
10.4.3 监控容器日志 221
10.5 Graylog 222
10.5.1 Graylog 架构 222
10.5.2 部署 Graylog 223
10.5.3 配置 Graylog 225
10.5.4 监控容器日志 227
10.6 小结 229
第11章 数据管理 230
11.1 从一个例子开始 230
11.2 实践 Rex-Ray driver 232
11.2.1 安装 Rex-Ray 232
11.2.2 配置 VirtualBox 234
11.2.3 创建Rex-Ray volume 236
11.2.4 使用 Rex-Ray volume 237
写在最后 243
2018-01-28
Go语言实战（中文高清版）
第1章 关于Go语言的介绍 1
1．1 用Go解决现代编程难题 2
1．1．1 开发速度 2
1．1．2 并发 3
1．1．3 Go语言的类型系统 5
1．1．4 内存管理 7
1．2 你好，Go 7
1．3 小结 8
第2章 快速开始一个Go程序 9
2．1 程序架构 9
2．2 main包 11
2．3 search包 13
2．3．1 search．go 13
2．3．2 feed．go 21
2．3．3 match．go default．go 24
2．4 RSS匹配器 30
2．5 小结 36
第3章 打包和工具链 37
3．1 包 37
3．1．1 包名惯例 38
3．1．2 main包 38
3．2 导入 39
3．2．1 远程导入 40
3．2．2 命名导入 40
3．3 函数init 41
3．4 使用Go的工具 42
3．5 进一步介绍Go开发工具 44
3．5．1 go vet 44
3．5．2 Go代码格式化 45
3．5．3 Go语言的文档 45
3．6 与其他Go开发者合作 48
3．7 依赖管理 48
3．7．1 第三方依赖 49
3．7．2 对gb的介绍 50
3．8 小结 52
第4章 数组、切片和映射 53
4．1 数组的内部实现和基础功能 53
4．1．1 内部实现 53
4．1．2 声明和初始化 54
4．1．3 使用数组 55
4．1．4 多维数组 58
4．1．5 在函数间传递数组 59
4．2 切片的内部实现和基础功能 60
4．2．1 内部实现 60
4．2．2 创建和初始化 61
4．2．3 使用切片 63
4．2．4 多维切片 74
4．2．5 在函数间传递切片 75
4．3 映射的内部实现和基础功能 76
4．3．1 内部实现 76
4．3．2 创建和初始化 78
4．3．3 使用映射 79
4．3．4 在函数间传递映射 81
4．4 小结 82
第5章 Go语言的类型系统 83
5．1 用户定义的类型 83
5．2 方法 87
5．3 类型的本质 90
5．3．1 内置类型 91
5．3．2 引用类型 91
5．3．3 结构类型 93
5．4 接口 95
5．4．1 标准库 96
5．4．2 实现 98
5．4．3 方法集 99
5．4．4 多态 103
5．5 嵌入类型 105
5．6 公开或未公开的标识符 113
5．7 小结 121
第6章 并发 122
6．1 并发与并行 122
6．2 goroutine 125
6．3 竞争状态 132
6．4 锁住共享资源 135
6．4．1 原子函数 135
6．4．2 互斥锁 138
6．5 通道 140
6．5．1 无缓冲的通道 141
6．5．2 有缓冲的通道 146
6．6 小结 149
第7章 并发模式 150
7．1 runner 150
7．2 pool 158
7．3 work 168
7．4 小结 174
第8章 标准库 176
8．1 文档与源代码 177
8．2 记录日志 178
8．2．1 log包 179
8．2．2 定制的日志记录器 182
8．2．3 结论 186
8．3 编码 解码 187
8．3．1 解码JSON 187
8．3．2 编码JSON 192
8．3．3 结论 193
8．4 输入和输出 193
8．4．1 Writer和Reader接口 194
8．4．2 整合并完成工作 195
8．4．3 简单的curl 199
8．4．4 结论 200
8．5 小结 200
第9章 测试和性能 201
9．1 单元测试 201
9．1．1 基础单元测试 202
9．1．2 表组测试 205
9．1．3 模仿调用 208
9．1．4 测试服务端点 212
9．2 示例 217
9．3 基准测试 220
9．4 小结 224
2018-06-03
每天5分钟玩转Kubernetes
第1章 先把 Kubernetes 跑起来 1
1.1 先跑起来 1
1.2 创建 Kubernetes 集群 2
1.3 部署应用 4
1.4 访问应用 5
1.5 Scale 应用 6
1.6 滚动更新 7
1.7 小结 8
第2章 重要概念 9
第3章 部署 Kubernetes Cluster 13
3.1 安装 Docker 14
3.2 安装 kubelet、kubeadm 和 kubectl 14
3.3 用 kubeadm 创建 Cluster 14
3.3.1 初始化Master 14
3.3.2 配置 kubectl 16
3.3.3 安装Pod网络 16
3.3.4 添加 k8s-node1 和 k8s-node2 16
3.4 小结 18
第4章 Kubernetes 架构 19
4.1 Master 节点 19
4.2 Node 节点 20
4.3 完整的架构图 21
4.4 用例子把它们串起来 22
4.5 小结 24
第5章 运行应用 25
5.1 Deployment 25
5.1.1 运行Deployment 25
5.1.2 命令 vs 配置文件 29
5.1.3 Deployment 配置文件简介 30
5.1.4 伸缩 31
5.1.5 Failover 33
5.1.6 用label 控制 Pod 的位置 33
5.2 DaemonSet 36
5.2.1 kube-flannel-ds 36
5.2.2 kube-proxy 37
5.2.3 运行自己的 DaemonSet 38
5.3 Job 40
5.3.1 Pod 失败的情况 41
5.3.2 Job 的并行性 43
5.3.3 定时 Job 45
5.4 小结 48
第6章 通过 Service 访问 Pod 49
6.1 创建 Service 49
6.2 Cluster IP 底层实现 51
6.3 DNS 访问 Service 53
6.4 外网如何访问 Service 55
6.5 小结 58
第7章 Rolling Update 59
7.1 实践 59
7.2 回滚 61
7.3 小结 63
第8章 Health Check 64
8.1 默认的健康检查 64
8.2 Liveness 探测 65
8.3 Readiness 探测 67
8.4 Health Check 在 Scale Up 中的应用 69
8.5 Health Check 在滚动更新中的应用 71
8.6 小结 75
第9章 数据管理 76
9.1 Volume 76
9.1.1 emptyDir 76
9.1.2 hostPath 78
9.1.3 外部 Storage Provider 79
9.2 PersistentVolume & PersistentVolumeClaim 81
9.2.1 NFS PersistentVolume 81
9.2.2 回收 PV 84
9.2.3 PV 动态供给 86
9.3 一个数据库例子 87
9.4 小结 91
第10章 Secret & Configmap 92
10.1 创建 Secret 92
10.2 查看 Secret 93
10.3 在Pod中使用Secret 94
10.3.1 Volume 方式 94
10.3.2 环境变量方式 96
10.4 ConfigMap 97
10.5 小结 100
第11章 Helm—Kubernetes的包管理器 101
11.1 Why Helm 101
11.2 Helm 架构 103
11.3 安装 Helm 104
11.3.1 Helm 客户端 104
11.3.2 Tiller服务器 105
11.4 使用Helm 106
11.5 chart 详解 109
11.5.1 chart 目录结构 109
11.5.2 chart 模板 113
11.5.3 再次实践 MySQL chart 115
11.5.4 升级和回滚 release 118
11.5.5 开发自己的 chart 119
11.6 小结 126
第12章 网 络 127
12.1 Kubernetes 网络模型 127
12.2 各种网络方案 128
12.3 Network Policy 129
12.3.1 部署 Canal 129
12.3.2 实践 Network Policy 130
12.4 小结 135
第13章 Kubernetes Dashboard 136
13.1 安装 136
13.2 配置登录权限 137
13.3 Dashboard 界面结构 139
13.4 典型使用场景 140
13.4.1 部署 Deployment 140
13.4.2 在线操作 141
13.4.3 查看资源详细信息 142
13.4.4 查看 Pod 日志 142
13.5 小结 143
第14章 Kubernetes 集群监控 144
14.1 Weave Scope 144
14.1.1 安装 Scope 144
14.1.2 使用 Scope 145
14.2 Heapster 151
14.2.1 部署 151
14.2.2 使用 152
14.3 Prometheus Operator 155
14.3.1 Prometheus 架构 159
14.3.2 Prometheus Operator 架构 161
14.3.3 部署 Prometheus Operator 162
14.4 小结 167
第15章 Kubernetes 集群日志管理 168
15.1 部署 168
15.2 小结 173
写在最后 174
2018-06-03
深入理解Spring Cloud与微服务构建
第1章 微服务简介 1
1.1 单体架构及其存在的不足 1
1.1.1 单体架构简介 1
1.1.2 单体架构存在的不足 2
1.1.3 单体架构使用服务器集群
及存在的不足 2
1.2 微服务 3
1.2.1 什么是微服务 4
1.2.2 微服务的优势 8
1.3 微服务的不足 9
1.3.1 微服务的复杂度 9
1.3.2 分布式事务 9
1.3.3 服务的划分 11
1.3.4 服务的部署 11
1.4 微服务和SOA的关系 12
1.5 微服务的设计原则 12
第2章 Spring Cloud简介 14
2.1 微服务应该具备的功能 14
2.1.1 服务的注册与发现 15
2.1.2 服务的负载均衡 15
2.1.3 服务的容错 17
2.1.4 服务网关 18
2.1.5 服务配置的统一管理 19
2.1.6 服务链路追踪 20
2.2 Spring Cloud 21
2.2.1 简介 21
2.2.2 常用组件 21
2.2.3 项目一览表 23
2.3 Dubbo简介 24
2.4 Spring Cloud与Dubbo比较 25
2.5 Kubernetes简介 26
2.6 Spring Could与Kubernetes比较 27
2.7 总结 29
第3章 构建微服务的准备 30
3.1 JDK的安装 30
3.1.1 JDK的下载和安装 30
3.1.2 环境变量的配置 30
3.2 IDEA的安装 31
3.2.1 IDEA的下载 31
3.2.2 用IDEA创建一个Spring Boot
工程 32
3.2.3 用IDEA启动多个Spring Boot
工程实例 34
3.3 构建工具Maven的使用 35
3.3.1 Maven简介 35
3.3.2 Maven的安装 35
3.3.3 Maven的核心概念 37
3.3.4 编写Pom文件 37
3.3.5 Maven构建项目的生命周期 39
3.3.6 常用的Maven命令 40
第4章 开发框架Spring Boot 43
4.1 Spring Boot简介 43
4.1.1 Spring Boot的特点 43
4.1.2 Spring Boot的优点 44
4.2 用IDEA构建Spring Boot工程 44
4.2.1 项目结构 44
4.2.2 在Spring Boot工程中构建
Web 45
4.2.3 Spring Boot的测试 46
4.3 Spring Boot配置文件详解 46
4.3.1 自定义属性 47
4.3.2 将配置文件的属性赋给
实体类 47
4.3.3 自定义配置文件 49
4.3.4 多个环境的配置文件 50
4.4 运行状态监控Actuator 50
4.4.1 查看运行程序的健康状态 52
4.4.2 查看运行程序的Bean 53
4.4.3 使用Actuator关闭应用程序 55
4.4.4 使用shell连接Actuator 56
4.5 Spring Boot整合JPA 57
4.6 Spring Boot整合Redis 60
4.6.1 Redis简介 60
4.6.2 Redis的安装 60
4.6.3 在Spring Boot中使用Redis 60
4.7 Spring Boot整合Swagger2，搭建
Restful API在线文档 62
第5章 服务注册和发现Eureka 66
5.1 Eureka简介 66
5.1.1 什么是Eureka 66
5.1.2 为什么选择Eureka 66
5.1.3 Eureka的基本架构 67
5.2 编写Eureka Server 67
5.3 编写Eureka Client 70
5.4 源码解析Eureka 73
5.4.1 Eureka的一些概念 73
5.4.2 Eureka的高可用架构 74
5.4.3 Register服务注册 74
5.4.4 Renew服务续约 78
5.4.5 为什么Eureka Client获取
服务实例这么慢 80
5.4.6 Eureka 的自我保护模式 80
5.5 构建高可用的Eureka Server集群 81
5.6 总结 83
第6章 负载均衡Ribbon 84
6.1 RestTemplate简介 84
6.2 Ribbon简介 85
6.3 使用RestTemplate和Ribbon来消费
服务 85
6.4 LoadBalancerClient简介 88
6.5 源码解析Ribbon 90
第7章 声明式调用Feign 101
7.1 写一个Feign客户端 101
7.2 FeignClient详解 105
7.3 FeignClient的配置 106
7.4 从源码的角度讲解Feign的工作
原理 107
7.5 在Feign中使用HttpClient和
OkHttp 110
7.6 Feign是如何实现负载均衡的 112
7.7 总结 114
第8章 熔断器Hystrix 115
8.1 什么是Hystrix 115
8.2 Hystrix解决了什么问题 115
8.3 Hystrix的设计原则 117
8.4 Hystrix的工作机制 117
8.5 在RestTemplate和Ribbon上使用
熔断器 118
8.6 在Feign上使用熔断器 119
8.7 使用Hystrix Dashboard监控熔断器的
状态 120
8.7.1 在RestTemplate中使用Hystrix Dashboard 120
8.7.2 在Feign中使用
Hystrix Dashboard 123
8.8 使用Turbine聚合监控 124
第9章 路由网关Spring Cloud Zuul 126
9.1 为什么需要Zuul 126
9.2 Zuul的工作原理 126
9.3 案例实战 128
9.3.1 搭建Zuul服务 128
9.3.2 在Zuul上配置API接口的
版本号 131
9.3.3 在Zuul上配置熔断器 132
9.3.4 在Zuul中使用过滤器 133
9.3.5 Zuul的常见使用方式 135
第10章 配置中心
Spring Cloud Config 137
10.1 Config Server从本地读取配置
文件 137
10.1.1 构建Config Server 137
10.1.2 构建Config Client 138
10.2 Config Server从远程Git仓库读取
配置文件 140
10.3 构建高可用的Config Server 141
10.3.1 构建Eureka Server 141
10.3.2 改造Config Server 142
10.3.3 改造Config Client 143
10.4 使用Spring Cloud Bus刷新配置 144
第11章 服务链路追踪
Spring Cloud Sleuth 147
11.1 为什么需要Spring Cloud Sleuth 147
11.2 基本术语 147
11.3 案例讲解 148
11.3.1 构建Zipkin Server 148
11.3.2 构建User Service 149
11.3.3 构建Gateway Service 151
11.3.4 项目演示 152
11.4 在链路数据中添加自定义数据 153
11.5 使用RabbitMQ 传输链路数据 154
11.6 在MySQL数据库中存储链路数据 155
11.6.1 使用Http传输链路数据，
并存储在MySQL数据
库中 156
11.6.2 使用RabbitMQ传输链路
数据，并存储在MySQL
数据库中 157
11.7 在ElasticSearch中存储链路数据 158
11.8 用Kibana展示链路数据 159
第12章 微服务监控
Spring Boot Admin 161
12.1 使用Spring Boot Admin监控Spring Cloud微服务 161
12.1.1 构建Admin Server 161
12.1.2 构建Admin Client 163
12.2 在Spring Boot Admin中集成Turbine 166
12.2.1 改造Eureka Client 166
12.2.2 另行构建Eureka Client 167
12.2.3 构建Turbine工程 168
12.2.4 在Admin Server中集成
Turbine 169
12.3 在Spring Boot Admin中添加安全
登录界面 172
第13章 Spring Boot Security详解 174
13.1 Spring Security简介 174
13.1.1 什么是Spring Security 174
13.1.2 为什么选择Spring Security 174
13.1.3 Spring Security提供的安全
模块 175
13.2 Spring Boot Security与Spring Security
的关系 176
13.3 Spring Boot Security案例详解 176
13.3.1 构建Spring Boot Security
工程 176
13.3.2 配置Spring Security 178
13.3.3 编写相关界面 180
13.3.4 Spring Security方法级别上
的保护 185
13.3.5 从数据库中读取用户的
认证信息 188
13.4 总结 193
第14章 使用Spring Cloud OAuth2
保护微服务系统 195
14.1 什么是OAuth2 195
14.2 如何使用Spring OAuth2 196
14.2.1 OAuth2 Provider 196
14.2.2 OAuth2 Client 200
14.3 案例分析 201
14.3.1 编写Eureka Server 202
14.3.2 编写Uaa授权服务 202
14.3.3 编写service-hi资源服务 209
14.4 总结 215
第15章 使用Spring Security OAuth2
和JWT保护微服务系统 217
15.1 JWT简介 217
15.1.1 什么是JWT 217
15.1.2 JWT的结构 218
15.1.3 JWT的应用场景 219
15.1.4 如何使用JWT 219
15.2 案例分析 219
15.2.1 案例架构设计 219
15.2.2 编写主Maven工程 220
15.2.3 编写Eureka Server 221
15.2.4 编写Uaa授权服务 222
15.2.5 编写user-service资源服务 227
15.3 总结 236
第16章 使用Spring Cloud构建微
服务综合案例 237
16.1 案例介绍 237
16.1.1 工程结构 237
16.1.2 使用的技术栈 238
16.1.3 工程架构 238
16.1.4 功能展示 240
16.2 案例详解 244
16.2.1 准备工作 244
16.2.2 构建主Maven工程 244
16.2.3 构建eureka-server工程 245
16.2.4 构建config-server工程 246
16.2.5 构建zipkin-service工程 247
16.2.6 构建monitoring-service
工程 248
16.2.7 构建uaa-service工程 250
16.2.8 构建gateway-service工程 251
16.2.9 构建admin-service工程 253
16.2.10 构建user-service工程 253
16.2.11 构建blog-service工程 256
16.2.12 构建log-service工程 256
16.3 启动源码工程 260
16.4 项目演示 261
16.5 总结 262
2018-06-03
企业IT架构转型之道-阿里巴巴中台战略思想与架构实战
序言一
序言二
前言
**部分 引子
**章 阿里巴巴集团中台战略引发的思考
1.1 阿里巴巴共享业务事业部的发展史
1.2 企业信息中心发展的症结
第2章 构建业务中台的基础——共享服务体系
2.1 回归SOA的本质——服务重用
2.2 服务需要不断的业务滋养
2.3 共享服务体系是培育业务创新的土壤
2.4 赋予业务快速创新和试错能力
2.5 为真正发挥大数据威力做好储备
2.6 改变组织阵型会带来组织效能的提升
第二部分 共享服务体系搭建
第3章 分布式服务框架的选择
3.1 淘宝平台“服务化”历程
3.2 “中心化”与“去中心化”服务框架的对比
3.3 阿里巴巴分布式服务框架
3.4 关于微服务
第4章 共享服务中心建设原则
4.1 淘宝的共享服务中心概貌
4.2 什么是服务中心
4.3 服务中心的划分原则
第5章 数据拆分实现数据库能力线性扩展
5.1 数据库瓶颈阻碍业务的持续发展
5.2 数据库分库分表的实践
第6章 异步化与缓存原则
6.1 业务流程异步化
6.2 数据库事务异步化
6.3 事务与柔性事务
6.4 大促**活动催生缓存技术的高度使用
第7章 打造数字化运营能力
7.1 业务服务化带来的问题
7.2 鹰眼平台的架构
7.3 埋点和输出日志
7.4 海量日志分布式处理平台
7.5 日志收集控制
7.6 典型业务场景
第8章 打造平台稳定性能力
8.1 限流和降级
8.2 流量调度
8.3 业务开关
8.4 容量压测及评估规划
8.5 全链路压测平台
8.6 业务一致性平台
第9章 共享服务中心对内和对外的协作共享
9.1 服务化建设野蛮发展带来的问题
9.2 共享服务平台的建设思路
9.3 共享服务平台与业务方协作
9.4 业务中台与前端应用协作
9.5 业务中台绩效考核
9.6 能力开放是构建生态的基础
第三部分 阿里巴巴能力输出与案例
10章 大型央企互联网转型
10.1 项目背景
10.2 项目实施
10.3 客户收益
10.4 笔者感想
10.5 项目后记
11章 时尚行业品牌公司互联网转型
11.1 项目背景
11.2 供应链的改造
11.3 基于SCRM的全渠道整合营销
11.4 小结
2018-06-03
Go 1.11.4安装文件
从官网下载的最新版本的安装文件，包括了Windows、Mac、Linux版本，内含三个文件：go1.11.4.darwin-amd64.pkg、go1.11.4.linux-amd64.tar.gz、go1.11.4.windows-amd64.msi
2019-01-17
Spring微服务实战（中文-高清完整版）
1. 欢迎来到Cloud和Spring 1
1.1什么是微服务？ 2
1.2什么是Spring，它和微服务有什么关联？ 5
1.3你将从这本书里学到什么？ 6
1.4为什么这本书不你有关？ 7
1.5使用Spring Boot构建一个微服务 8
1.6为什么要改变我们构建应用程序的方式？ 12
1.7云究竟是什么？ 13
1.8为什么是云和微服务？ 15
1.9微服务丌仅仅是编写代码 19
1.9.1微服务核心开发模式 19
1.9.2微服务路由模式 20
1.9.3微服务客户端弹性模式 21
1.9.4微服务安全模式 23
1.9.5微服务日志记录和跟踪模式 24
1.9.6微服务构建和部署模式 25
1.10使用Spring Cloud构建微服务 26
1.10.1 Spring Boot 28
1.10.2 Spring Cloud Config 28
1.10.3 Spring Cloud Service Discovery 28
1.10.4 Spring Cloud/Netflix Hystrix and Ribbon 29
1.10.5 Spring Cloud/Netflix Zuul 29
1.10.6 Spring Cloud Stream 29
1.10.7 Spring Cloud Sleuth 29
1.10.8 Spring Cloud Security 30
1.10.9 准备些什么？ 30
1.11使用Spring Cloud举例 30
1.12了解不我们相关的例子 33
1.13小结 33
2. 使用Spring Boot构建微服务 35
2.1架构师的故事：设计微服务架构 38
2.1.1分解业务问题 38
2.1.2确定服务粒度 41
2.1.3互相交谈：服务接口 43
2.2什么时候丌使用微服务 44
2.2.1分布式系统构建的复杂性 44
2.2.2服务器扩展 44
2.2.3应用类型 44
2.2.4数据转换和一致性 45
2.3开发：使用Spring Boot和Java构建一个微服务 45
2.3.1从骨架项目快速入门 46
2.3.2编写引导类,启劢你的Spring Boot应用 47
2.3.3创建微服务的访问入口：Spring Boot控制器 48
2.4运维：严格的运行时构建 53
2.4.1服务装配：打包和部署微服务 56
2.4.2服务引导：管理微服务的配置 58
2.4.3服务注册不发现：客户端如何不微服务通信 59
2.4.4监控微服务健康状况 60
2.5观点汇总 62
2.6小结 63
3. 使用Spring Cloud Configuration Server控制配置 64
3.1管理配置（和复杂性） 65
3.1.1配置管理架构 67
3.1.2实现选择 69
3.2建立Spring Cloud Config Server 70
3.2.1创建Spring Cloud配置引导类 74
3.2.2通过配置文件使用Spring Cloud Config Server 75
3.3将Spring Cloud配置不Spring Boot客户端集成 77
3.3.1配置Spring Cloud Config Server的依赖 79
3.3.2 Spring Cloud Config使用配置 79
3.3.3使用Spring Cloud Configuration Server配置数据源 83
3.3.4使用@Value注解直接读取属性 86
3.3.5通过Git使用Spring Cloud Config Server 87
3.3.6通过Spring Cloud Config Server刷新属性 88
3.4保护敏感配置信息 89
3.4.1下载和安装加密所需的Oracle JCE JAR包 90
3.4.2配置加密密钥 91
3.4.3加密和解密属性 91
3.4.4配置微服务使用加密的客户端 93
3.5最后的思考 95
3.6小结 95
4. 服务发现 96
4.1我的服务在哪里？ 97
4.2关于云端服务发现的研究 100
4.2.1服务发现架构 100
4.2.2使用Spring和Netflix Eureka实现服务发现 103
4.3创建Spring Eureka Service 105
4.4使用Spring Eureka注册服务 107
4.5使用服务发现查找服务 111
4.5.1使用Spring DiscoveryClient查找服务实例 112
4.5.2使用Ribbon-aware Spring RestTemplate调用服务 114
4.5.3使用Netflix Feign client调用服务 116
4.6小结 118
5. 坏事发生时：使用Spring Cloud和Netflix Hystrix的客户端弹性模式119
5.1客户端的弹性模式 120
5.1.1客户端负载均衡 121
5.1.2断路器 122
5.1.3回退处理 122
5.1.4舱壁 122
5.2客户端弹性的重要性 123
5.3熔断机制 126
5.4配置使用Spring Cloud和Hystrix的依赖 127
5.5使用Hystrix实现断路器 128
5.5.1调用微服务超时 131
5.5.2自定义断路器上的超时时间 132
5.6回退处理 133
5.7舱壁模式的实现 136
5.8深入理解Hystrix 138
5.8.1进一步理解Hystrix配置 142
5.9线程上下文和Hystrix 144
5.9.1 ThreadLocal 和 Hystrix 144
5.9.2 Hystrix并发策略 147
5.10小结 151
6. 使用Spring Cloud和Zuul进行服务路由 153
6.1服务网关 154
6.2 Spring Cloud和Netflix Zuul 157
6.2.1配置Spring Boot工程引用Zuul依赖 157
6.2.2使用SpringCloud注解配置Zuul服务 157
6.2.3配置Zuul不Eureka通信 158
6.3在Zuul中配置路由 159
6.3.1通过服务发现自劢映射路由 159
6.3.2通过服务发现手劢映射路由 161
6.3.3使用静态URL手劢映射路由 165
6.3.4劢态重新加载路由配置 168
6.3.5 Zuul和服务超时 169
6.4 Zuul过滤器 169
6.5创建pre类型Zuul过滤器生成关联ID 173
6.5.1在服务调用中使用关联ID 176
6.6创建post类型Zuul过滤器接收关联ID 182
6.7创建劢态路由过滤器 184
6.7.1构建路由过滤器的框架 186
6.7.2实现run方法 187
6.7.3转发路由 188
6.7.4把代码整合在一起 190
6.8小结 191
7. 微服务安全 192
7.1介绍OAuth2 193
7.2从小事做起：使用Spring和OAuth2保护一个单独的端点 195
7.2.1配置EagleEye OAuth2认证服务 196
7.2.2在OAuth2服务注册客户端应用 197
7.2.3配置EagleEye用户 200
7.2.4用户认证 202
7.3使用OAuth2保护组织服务 205
7.3.1为单独的服务添加Spring Security和OAuth2 JAR包 205
7.3.2配置服务指向OAuth2认证服务 206
7.3.3定义那些资源可以访问服务 207
7.3.4传递OAuth2访问令牌 210
7.4 JavaScript Web Tokens和OAuth2 213
7.4.1修改认证服务来发布JavaScript Web Tokens 214
7.4.2在微服务中消费JavaScript Web Tokens 218
7.4.3扩展JWT Token 220
7.4.4解析来自自定义字段的JavaScript token 222
7.5关于微服务安全的思考 224
7.6小结 227
8. Spring Cloud Stream的事件驱动架构 228
8.1 消息，EDA和微服务的案例 229
8.1.1使用同步请求响应的方法传递状态改变 230
8.1.2在服务乊间使用消息传递状态改变 233
8.1.3消息架构的缺点 235
8.2介绍Spring Cloud Stream 236
8.2.1 Spring Cloud Stream体系结构 237
8.3 写一个简单的消息生产者和消费者 238
8.3.1在组织服务中编写消息生产者 239
8.3.2在许可服务中编写消息消费者 244
8.3.3查看运行中的消息服务 247
8.4 Spring Cloud Stream使用案例：分布式缓存 249
8.4.1使用Redis缓存查找 250
8.4.2定义自定义channels 256
8.4.3将它们放在一起：收到消息时清除缓存 257
8.5小结 258
9. 使用Spring Cloud Sleuth和Zipkin进行分布式跟踪 259
9.1 Spring Cloud Sleuth和关联ID 260
9.1.1添加Spring Cloud Sleuth 261
9.1.2分析Spring Cloud Sleuth Trace 262
9.2日志聚合和Spring Cloud Sleuth 263
9.2.1 实战中的Spring Cloud Sleuth/Papertrail实现 265
9.2.2创建一个Papertrail账户并配置syslog连接器 267
9.2.3将Docker输出重定向到Papertrail 268
9.2.4在Papertrail里搜索Spring Cloud Sleuth Trace ID 270
9.2.5使用Zuul将关联ID添加到HTTP响应中 272
9.3使用Zipkin实现分布式跟踪 274
9.3.1配置Spring Cloud Sleuth和Zipkin依赖 275
9.3.2配置服务指向Zipkin 275
9.3.3安装和配置Zipkin Server 276
9.3.4设置跟踪级别 278
9.3.5使用Zipkin跟踪交易 278
9.3.6可视化更复杂的交易 281
9.3.7捕获消息跟踪 282
9.3.8添加自定义span 284
9.4小结 287
10. 部署微服务 288
10.1 EagleEye：在云环境中设置核心基础设施 290
10.1.1使用Amazon RDS创建PostgreSQL数据库 293
10.1.2在Amazon创建Redis集群 296
10.1.3创建ECS（弹性可伸缩的计算服务）集群 298
10.2除了基础设施：部署EagleEye 302
10.2.1在ECS中手劢部署EagleEye服务 303
10.3构建/部署管道的架构 305
10.4构建和部署管道 309
10.5开始你的构建/部署管道：GitHub和Travis CI 311
10.6在Travis CI中构建服务 312
10.6.1核心构建运行时配置 315
10.6.2安装预构建工具 318
10.6.3执行构建 320
10.6.4标记源代码控制代码 320
10.6.5构建微服务和创建Docker镜像 321
10.6.6将镜像发布到Docker Hub 322
10.6.7在Amazon ECS环境中启劢服务 323
10.6.8开展平台测试 323
10.7关于构建/部署管道的总结 325
10.8小结 325
附录A：在桌面上运行云 327
附录B：OAuth2授权类型 336
2018-01-28
Kubernetes权威指南（第2版-高清书签版）
第1章 Kubernetes 入门 1
1.1 Kubernetes 是什么 1
1.2 为什么要用Kubernetes 4
1.3 从一个简单的例子开始 5
1.3.1 环境准备 6
1.3.2 启动MySQL 服务 7
1.3.3 启动Tomcat 应用 9
1.3.4 通过浏览器访问网页 11
1.4 Kubernetes 基本概念和术语 12
1.4.1 Master 12
1.4.2 Node 13
1.4.3 Pod 15
1.4.4 Label（标签） 19
1.4.5 Replication Controller（RC） 22
1.4.6 Deployment 25
1.4.7 Horizontal Pod Autoscaler（HPA） 27
1.4.8 Service（服务） 29
1.4.9 Volume（存储卷） 35
1.4.10 Persistent Volume 39
1.4.11 Namespace（命名空间） 40
1.4.12 Annotation（注解） 42
1.4.13 小结 42
第2章 Kubernetes 实践指南 43
2.1 Kubernetes 安装与配置 43
2.1.1 安装Kubernetes 43
2.1.2 配置和启动Kubernetes 服务 45
2.1.3 Kubernetes 集群的安全设置 51
2.1.4 Kubernetes 的版本升级 57
2.1.5 内网中的Kubernetes 相关配置 57
2.1.6 Kubernetes 核心服务配置详解 58
2.1.7 Kubernetes 集群网络配置方案 72
2.2 kubectl 命令行工具用法详解 80
2.2.1 kubectl 用法概述 80
2.2.2 kubectl 子命令详解 82
2.2.3 kubectl 参数列表 84
2.2.4 kubectl 输出格式 84
2.2.5 kubectl 操作示例 86
2.3 Guestbook 示例：Hello World 87
2.3.1 创建redis-master RC 和Service 89
2.3.2 创建redis-slave RC 和Service 91
2.3.3 创建frontend RC 和Service 93
2.3.4 通过浏览器访问frontend 页面 96
2.4 深入掌握Pod 97
2.4.1 Pod 定义详解 97
2.4.2 Pod 的基本用法 102
2.4.3 静态Pod 107
2.4.4 Pod 容器共享Volume 108
2.4.5 Pod 的配置管理 110
2.4.6 Pod 生命周期和重启策略 123
2.4.7 Pod 健康检查 124
2.4.8 玩转Pod 调度 126
2.4.9 Pod 的扩容和缩容 135
2.4.10 Pod 的滚动升级 139
2.5 深入掌握Service 143
2.5.1 Service 定义详解 143
2.5.2 Service 基本用法 145
2.5.3 集群外部访问Pod 或Service 150
2.5.4 DNS 服务搭建指南 153
2.5.5 Ingress：HTTP 7 层路由机制 161
第3章 Kubernetes 核心原理 165
3.1 Kubernetes API Server 原理分析 165
3.1.1 Kubernetes API Server 概述 165
3.1.2 独特的Kubernetes Proxy API 接口 168
3.1.3 集群功能模块之间的通信 169
3.2 Controller Manager 原理分析 170
3.2.1 Replication Controller 171
3.2.2 Node Controller 173
3.2.3 ResourceQuota Controller 174
3.2.4 Namespace Controller 176
3.2.5 Service Controller 与Endpoint Controller 176
3.3 Scheduler 原理分析 177
3.4 kubelet 运行机制分析 181
3.4.1 节点管理 181
3.4.2 Pod 管理 182
3.4.3 容器健康检查 183
3.4.4 cAdvisor 资源监控 184
3.5 kube-proxy 运行机制分析 186
3.6 深入分析集群安全机制 190
3.6.1 API Server 认证 190
3.6.2 API Server 授权 192
3.6.3 Admission Control 准入控制 194
3.6.4 Service Account 195
3.6.5 Secret 私密凭据 200
3.7 网络原理 203
3.7.1 Kubernetes 网络模型 203
3.7.2 Docker 的网络基础 205
3.7.3 Docker 的网络实现 217
3.7.4 Kubernetes 的网络实现 225
3.7.5 开源的网络组件 229
3.7.6 网络实战 234
第4章 Kubernetes 开发指南 247
4.1 REST 简述 247
4.2 Kubernetes API 详解 249
4.2.1 Kubernetes API 概述 249
4.2.2 API 版本 254
4.2.3 API 详细说明 254
4.2.4 API 响应说明 256
4.3 使用Java 程序访问Kubernetes API 258
4.3.1 Jersey 258
4.3.2 Fabric8 270
4.3.3 使用说明 271
第5章 Kubernetes 运维指南 292
5.1 Kubernetes 集群管理指南 292
5.1.1 Node 的管理 292
5.1.2 更新资源对象的Label 294
5.1.3 Namespace：集群环境共享与隔离 295
5.1.4 Kubernetes 资源管理 299
5.1.5 Kubernetes 集群高可用部署方案 333
5.1.6 Kubernetes 集群监控 343
5.1.7 kubelet 的垃圾回收（GC）机制 361
5.2 Kubernetes 高级案例 362
5.2.1 ElasticSearch 日志搜集查询和展现案例 362
5.2.2 Cassandra 集群部署案例 371
5.3 Trouble Shooting 指导 376
5.3.1 查看系统Event 事件 377
5.3.2 查看容器日志 379
5.3.3 查看Kubernetes 服务日志 379
5.3.4 常见问题 381
5.3.5 寻求帮助 384
5.4 Kubernetes v1.3 开发中的新功能 385
5.4.1 Pet Set（有状态的容器） 385
5.4.2 Init Container（初始化容器） 388
5.4.3 Cluster Federation（集群联邦） 391
第6章 Kubernetes 源码导读 396
6.1 Kubernetes 源码结构和编译步骤 396
6.2 kube-apiserver 进程源码分析 400
6.2.1 进程启动过程 400
6.2.2 关键代码分析 402
6.2.3 设计总结 417
6.3 kube-controller-manager 进程源码分析 420
6.3.1 进程启动过程 420
6.3.2 关键代码分析 423
6.3.3 设计总结 431
6.4 kube-scheduler 进程源码分析 433
6.4.1 进程启动过程 434
6.4.2 关键代码分析 438
6.4.3 设计总结 445
6.5 kubelet 进程源码分析 447
6.5.1 进程启动过程 447
6.5.2 关键代码分析 452
6.5.3 设计总结 475
6.6 kube-proxy 进程源码分析 476
6.6.1 进程启动过程 476
6.6.2 关键代码分析 478
6.6.3 设计总结 493
6.7 kubectl 进程源码分析 494
6.7.1 kubectl create 命令 495
6.7.2 rolling-update 命令 499
后记 505
2018-06-03
架构探险：从零开始写JavaWeb框架
第1章 从一个简单的Web应用 1
正所谓“工欲善其事，必先利其器”，在正式开始设计并开发我们的轻量级Java Web框架之前，有必要首先掌握以下技能：
使用IDEA搭建并开发Java项目；
使用Maven自动化构建Java项目；
使用Git管理项目源代码。
1．1 使用IDEA创建Maven项目 3
1．1．1 创建IDEA项目 3
1．1．2 调整Maven配置 3
1．2 搭建Web项目框架 5
1．2．1 转为Java Web项目 5
1．2．2 添加Java Web的Maven依赖 6
1．3 编写一个简单的Web应用 10
1．3．1 编写 Servlet类 10
1．3．2 编写JSP页面 11
1．4 让Web应用跑起来 12
1．4．1 在IDEA中配置Tomcat 12
1．4．2 使用Tomcat的Maven插件 13
1．4．3 以Debug方式运行程序 13
1．5 将代码放入Git仓库中 14
1．5．1 编写．gitignore文件 14
1．5．2 提交本地 Git 仓库 15
1．5．3 推送远程Git仓库 15
1．5．4 总结 16
第2章 为Web应用添加业务功能 17
我们将在这个应用的基础上增加一些业务功能，您将学会更多有关项目实战的技能，具体包括：
如何进行需求分析；
如何进行系统设计；
如何编写应用程序。
2．1 需求分析与系统设计 19
2．1．1 需求分析 19
2．1．2 系统设计 19
2．2 动手开发Web应用 21
2．2．1 创建数据库 22
2．2．2 准备开发环境 22
2．2．3 编写模型层 23
2．2．4 编写控制器层 25
2．2．5 编写服务层 27
2．2．6 编写单元测试 28
2．2．7 编写视图层 31
2．3 细节完善与代码优化 31
2．3．1 完善服务层 32
2．3．2 完善控制器层 59
2．3．3 完善视图层 60
2．4 总结 65
第3章 搭建轻量级Java Web框架 66
我们需要这样的框架，它足够轻量级、足够灵巧，不妨给它取一个优雅的名字――Smart Framework，本章我们就一起来实现这个框架。
您将通过本章的学习，掌握如下技能：
如何快速搭建开发框架；
如何加载并读取配置文件；
如何实现一个简单的IOC容器；
如何加载指定的类；
如何初始化框架。
3．1 确定目标 68
3．2 搭建开发环境 70
3．2．1 创建框架项目 70
3．2．2 创建示例项目 73
3．3 定义框架配置项 74
3．4 加载配置项 75
3．5 开发一个类加载器 78
3．6 实现Bean容器 87
3．7 实现依赖注入功能 90
3．8 加载Controller 93
3．9 初始化框架 97
3．10 请求转发器 98
3．11 总结 109
第4章 使框架具备AOP特性 110
在本章中，读者将学到大量有用的技术，具体包括：
如何理解并使用代理技术；
如何使用Spring提供的AOP技术；
如何使用动态代理技术实现AOP框架；
如何理解并使用ThreadLocal技术；
如何理解数据库事务管理机制；
如何使用AOP框架实现事务控制。
4．1 代理技术简介 112
4．1．1 什么是代理 112
4．1．2 JDK动态代理 114
4．1．3 CGlib动态代理 116
4．2 AOP技术简介 118
4．2．1 什么是AOP 118
4．2．2 写死代码 119
4．2．3 静态代理 120
4．2．4 JDK动态代理 121
4．2．5 CGLib动态代理 122
4．2．6 Spring AOP 124
4．2．7 Spring + AspectJ 136
4．3 开发AOP框架 142
4．3．1 定义切面注解 142
4．3．2 搭建代理框架 143
4．3．3 加载AOP框架 150
4．4 ThreadLocal简介 158
4．4．1 什么是ThreadLocal 158
4．4．2 自己实现ThreadLocal 161
4．4．3 ThreadLocal使用案例 163
4．5 事务管理简介 172
4．5．1 什么是事务 172
4．5．2 事务所面临的问题 173
4．5．3 Spring的事务传播行为 175
4．6 实现事务控制特性 178
4．6．1 定义事务注解 178
4．6．2 提供事务相关操作 181
4．6．3 编写事务代理切面类 182
4．6．4 在框架中添加事务代理机制 184
4．7 总结 185
第5章 框架优化与功能扩展 186
本章将对现有框架进行优化，并提供一些扩展功能。通过本章的学习，读者可以了解到：
如何优化Action参数；
如何实现文件上传功能；
如何与Servlet API完全解耦；
如何实现安全控制框架；
如何实现Web服务框架。
5．1 优化Action参数 188
5．1．1 明确Action参数优化目标 188
5．1．2 动手优化Action参数使用方式 188
5．2 提供文件上传特性 191
5．2．1 确定文件上传使用场景 191
5．2．2 实现文件上传功能 194
5．3 与Servlet API解耦 214
5．3．1 为何需要与Servlet API解耦 214
5．3．2 与Servlet API解耦的实现过程 215
5．4 安全控制框架――Shiro 219
5．4．1 什么是Shiro 219
5．4．2 Hello Shiro 220
5．4．3 在Web开发中使用Shiro 224
5．5 提供安全控制特性 230
5．5．1 为什么需要安全控制 230
5．5．2 如何使用安全控制框架 231
5．5．3 如何实现安全控制框架 242
5．6 Web服务框架――CXF 261
5．6．1 什么是CXF 261
5．6．2 使用CXF开发SOAP服务 262
5．6．3 基于SOAP的安全控制 278
5．6．4 使用CXF开发REST服务 291
5．7 提供Web服务特性 308
5．8 总结 329
附录A Maven快速入门 330
附录B 将构件发布到Maven中央仓库 342
2018-03-12
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人