- 博客(303)
- 资源 (514)
- 收藏
- 关注
RSS订阅原创 Spring Boot 4.0技术选型深度剖析：Kotlin与Java的架构决策指南
在Spring Boot 4.0正式发布之际，众多开发团队面临着一个关键的架构决策：继续使用传统的Java还是转向日益流行的Kotlin？这个决策不仅影响当前的开发效率，更关系到未来3-5年的技术债务和维护成本。根据JetBrains 2023年的开发者调查报告，，较前一年增长8个百分点，这表明Kotlin正在成为企业级开发的重要选择。本文将从技术特性、团队因素、业务场景和长期维护四个维度，深入分析Spring Boot 4.0中Kotlin与Java的优劣对比，为架构决策提供系统化的评估框架。
2025-11-24 12:45:00
120
原创 Spring Boot 4.0架构革新：构建更精简、更安全、更高效的Java应用
Spring Boot 4.0的创新设计反映了Java生态系统对现代软件挑战的响应。通过精简架构增强类型安全和优化性能表现，它为开发者提供了构建下一代应用的坚实基础。这些改进不仅仅是技术特性的堆砌，更是对软件设计哲学的深刻思考和实践。正如城市发展需要不断更新基础设施同时保留文化底蕴，软件框架的演进也需要在创新与稳定、灵活与一致、功能与复杂度之间找到平衡。Spring Boot 4.0成功地走出了这条平衡之路，为Java生态系统的持续繁荣注入了新的活力。
2025-11-24 07:00:00
23
原创 Java锁的深度演进与创新设计：从并发瓶颈到高性能架构实践
AQS的核心设计// 简化的AQS实现原理// 同步状态// 等待队列节点// 获取锁的模板方法if (!// 由子类实现的具体获取逻辑Java锁架构的演进历程体现了软件工程中不断优化和创新的精神。从最初的重量级synchronized，到基于AQS的灵活锁框架，再到无锁编程和分布式锁，每一次演进都是为了解决特定场景下的性能瓶颈和业务需求。关键演进点总结性能优化：从重量级锁到轻量级锁、偏向锁，减少系统调用开销功能丰富：从基本的互斥到可中断、超时、公平性等高级特性场景适配。
2025-11-20 12:45:00
862
原创 HTTP/3与QUIC深度解析：下一代Web传输技术的革命性融合
当我们回顾HTTP协议的发展历程，会发现一条清晰的技术演进路径：从HTTP/1.1的文本传输到HTTP/2的二进制分帧，再到如今HTTP/3的传输层革命。HTTP/3的诞生标志着Web传输技术进入了一个全新时代，它不再是对前代协议的简单优化，而是从开始的重构与创新。根据W3Techs在2025年初的统计数据显示，全球排名前1000万的网站中已有超过35%支持HTTP/3，而在一年前这一数字仅为15%。这种爆发式增长背后，是HTTP/3基于QUIC协议所带来的和。
2025-11-20 07:00:00
675
原创 QUIC协议深度解析：重塑互联网传输层的创新架构
在当今高速发展的互联网环境中，传统传输控制协议（TCP）已逐渐暴露出诸多性能瓶颈。由Google于2012年发起并主导设计的QUIC（Quick UDP Internet Connections）协议，旨在解决TCP的固有缺陷，满足现代网络应用对的迫切需求。QUIC并非简单的功能增强，而是从架构层面重新设计了互联网传输层，通过，实现了既保持UDP部署灵活性的同时，又获得了比TCP更优秀的性能表现。，以及。
2025-11-19 12:45:00
1077
原创 事务隔离级别的架构演进与创新设计：从理论到实践
在当今的互联网应用中，数据一致性是所有架构师必须面对的核心挑战。想象一下这样的场景：当你在电商平台下单时，库存的扣减、订单的创建、支付的处理必须在同一个逻辑单元中完成——要么全部成功，要么全部失败。这种“全有或全无”的特性，正是事务处理要解决的根本问题。事务隔离级别作为数据库系统的核心特性，直接影响着系统的并发性能和数据一致性。在这篇文章中，我们将深入探讨事务隔离级别的架构设计，从基础理论到创新实践，从问题起源到解决方案，为您呈现一幅完整的技术演进图景。
2025-11-18 12:45:00
1058
原创 分布式一致性：从理论到实践的架构演进与创新设计
在分布式系统中，一致性指的是多个数据副本之间保持相同状态的特性。强一致性：任何读写操作都能看到最新写入的数据弱一致性：系统不保证立即看到最新写入的数据最终一致性：保证如果没有新的更新，最终所有访问都将返回最后更新的值。
2025-11-18 07:00:00
685
原创 CQRS架构革命：从读写耦合到极致性能的设计演进
利用云函数实现无服务器的命令和查询处理器实时数据流：与流处理平台（如Kafka、Pulsar）深度集成AI增强：利用机器学习优化查询性能和资源分配多模型数据库：结合图数据库、时序数据库等优化特定查询场景CQRS架构通过将读写职责分离，为复杂业务系统提供了强大的架构支撑。从传统的CRUD架构演进到CQRS，不仅仅是技术上的改变，更是对业务本质的深度思考。CQRS的核心价值解决读写负载不匹配问题优化复杂业务逻辑的实现提供更好的扩展性和性能支持事件驱动和事件溯源架构实施建议。
2025-11-17 12:45:00
760
原创 MVCC架构演进与创新设计：从并发冲突到多版本管理
MVCC作为现代数据库系统的核心技术，通过多版本管理优雅地解决了并发控制中的读写冲突问题。从PostgreSQL的追加式版本存储到MySQL InnoDB的回滚段实现，不同的MVCC实现方案各有优劣，但核心思想都是通过维护数据的历史版本来实现非阻塞的并发访问。
2025-11-17 07:00:00
1448
原创 块量化：打破大模型部署的内存墙，通往高效推理的架构革命
我们将从量化技术的基础讲起，揭示传统方法的痛点，详细阐述块量化的设计原理与优势，并通过生活化的案例和可执行的代码示例，让你彻底理解这一技术。最后，我们还将展望其未来的发展方向。块量化技术通过引入“分块”这一简单的架构思想，巧妙地解决了异常值对极低比特量化的干扰问题，为大模型的高效部署打开了新的空间。NF4不是线性的，它的量化等级是非均匀的，在零点附近更密集，在分布的两端更稀疏。：由于每个块的范围更紧凑，缩放因子 S 更小，在相同的比特数下，每个块内用于表示数值的“等级”更多，从而显著降低了量化误差。
2025-11-14 07:00:00
1557
原创 MySQL事务隔离级别：从并发困境到架构革新
在当今数据驱动的时代，数据库事务处理如同现实世界中的金融交易，需要确保数据的一致性、可靠性和隔离性。想象一下银行转账场景：如果A向B转账100元，这个操作必须要么完全成功（A账户减100，B账户加100），要么完全失败，绝不能出现中间状态。这就是事务的原子性要求。然而，当多个事务同时执行时，数据库系统面临着一个核心挑战：如何在保证数据正确性的同时，提供尽可能高的并发性能？MySQL作为世界上最流行的开源关系数据库，其事务隔离级别的架构设计正是为了解决这一“平行宇宙”难题而诞生的精妙解决方案。
2025-11-13 12:45:00
1121
原创 预写日志（WAL）：数据库的“记账本”原理
预写日志是一种数据安全保护机制在真正修改数据之前，先把要做什么事记录下来。就像我们写日记：先在本子上写下“明天要去银行存钱”第二天按照记录去执行如果中途生病了，康复后看看日记就知道该做什么。
2025-11-13 07:00:00
1027
原创 预写日志（WAL）：数据持久化的守护者与现代架构创新
在当今数据驱动的时代，数据持久化是每个系统架构师必须面对的核心挑战。想象一下，当我们进行在线银行转账时，系统突然崩溃，如果转账操作没有正确持久化，可能导致资金丢失或账户不一致。这正是预写日志（Write-Ahead Logging, WAL）技术要解决的根本问题。预写日志不仅是数据库系统的核心组件，更是现代分布式系统的基石。从传统的关系型数据库到新兴的分布式存储系统，WAL无处不在，默默守护着数据的一致性。本文将深入探讨WAL的架构设计、演进历程，并通过生活化案例和代码示例，揭示这一技术的内在精妙之处。
2025-11-12 12:45:00
1408
原创 多租户数据隔离架构：从基础隔离到智能自治的演进之路
在当今云计算和SaaS（Software as a Service）服务模式主导的时代，多租户架构已成为支撑现代互联网应用的核心技术范式。多租户架构允许多个客户（称为“租户”）共享同一套应用程序实例，同时确保各租户数据的隔离性和安全性。这种架构模式通过资源共享实现了显著的规模经济效益，降低了运营成本，同时为租户提供了可定制化的服务体验。
2025-11-12 07:00:00
684
原创 MySQL索引架构设计：从数据查找到性能优化的演进之路
索引的本质是一种数据结构，它通过维护特定字段或字段组合的有序引用，极大地加速数据检索速度。书籍目录：按主题或字母顺序排列，快速定位内容页码数据库索引：按指定字段值排序，快速定位数据存储位置大幅减少磁盘I/O：从全表扫描变为有限范围查找提高查询性能：特别是等值查询和范围查询保证数据唯一性：唯一索引约束加速表连接：外键关联查询优化。
2025-11-11 12:45:00
1154
原创 超时控制与强制终止：SIGTERM到SIGKILL的优雅降级策略
在完美的世界里，所有的进程都会在收到SIGTERM信号后立即优雅地关闭自己。然而现实往往更加复杂：进程可能因为各种原因无法及时响应终止请求——可能是陷入了无限循环、正在处理重要数据、等待外部资源，或者出现了无法预期的死锁。在这种情况下，我们需要一套完善的超时控制机制，实现从优雅终止到强制终止的平稳降级。想象一下交通管理的场景：当某个路口需要关闭时，交通警察会首先给出警告和准备时间（SIGTERM），让车辆有机会完成当前操作或寻找替代路线。
2025-11-11 07:00:00
1625
原创 SIGTERM与SIGKILL：进程终止的优雅与强制之道
在现代操作系统中，进程管理是核心功能之一。就像人类社会需要有序的管理机制来处理各种情况一样，操作系统也需要一套完善的机制来管理进程的创建、执行和终止。在这套机制中，信号（Signal）扮演着至关重要的角色，特别是SIGTERM和SIGKILL这两个用于进程终止的信号。想象一下，当我们需要关闭一个正在运行的程序时，不同的关闭方式会带来截然不同的结果。优雅地请求程序自行关闭，还是强制立即终止它？这不仅仅是用户体验的差异，更关系到数据完整性、资源清理和系统稳定性。
2025-11-10 12:45:00
1763
原创 可解释AI（XAI）：构建透明可信人工智能的架构设计与实践
随着人工智能技术在医疗诊断、自动驾驶、金融风控等关键领域的深入应用，模型的复杂性和黑盒特性已成为制约其广泛部署的主要障碍。本文从专业架构师视角出发，系统阐述可解释AI（XAI）的技术原理、架构设计和实现方法。通过分析传统黑盒模型存在的问题，追溯XAI技术的发展演进，结合生活化案例和代码实践，深入探讨如何构建透明、可信、可解释的人工智能系统。本文还提出了面向未来的XAI架构设计原则和实践路径，为构建下一代可信AI系统提供技术参考。
2025-11-10 07:00:00
1432
原创 RPO与RTO的创新设计：从理论到实践的业务连续性架构
在当今高度数字化的时代，业务系统的连续性和数据安全性已成为企业的生命线。作为业务连续性与灾难恢复领域的核心指标，RPO（Recovery Point Objective，恢复点目标）和RTO（Recovery Time Objective，恢复时间目标）共同构成了衡量企业容灾能力的关键尺度。代表灾难发生后业务系统所能容忍的，即从最后一次备份到故障发生的时间间隔；而则指从系统宕机到所需的最长时间。这两个指标直接决定了企业在面临系统故障、自然灾害或人为错误时的业务恢复能力。
2025-11-07 07:00:00
967
原创 架构师成长迷思：突破架构设计能力提升的瓶颈与实战策略
在当今快速发展的互联网行业中，架构设计能力已成为衡量技术人员专业水平的重要标尺。然而，许多工程师在从初级开发向资深架构师转型的过程中，常常陷入能力提升的瓶颈期。这种现象不仅存在于个人职业发展，也反映在企业技术团队的整体能力建设上。架构设计本质上是一种，它要求设计者不仅具备扎实的技术功底，更需要拥有系统思维、业务洞察和前瞻性规划等综合能力。正如著名计算机科学家林纳斯·托瓦兹所言：“烂程序员关心代码，好程序员关心数据结构和它们之间的关系。
2025-11-06 12:45:00
1144
原创 简单性原则：构建可靠、可扩展且易于维护的软件架构
在软件工程的发展历程中，我们见证了一个令人深思的现象：随着技术栈的不断丰富和业务需求的日益复杂，软件系统的复杂性呈现出指数级增长。然而，这种复杂性的增长往往并非源于业务本质的要求，而是来自于过度设计、技术选型不当和架构决策失误。正如Unix哲学所倡导的“简单优于复杂”，在当今快速变化的数字时代，这一原则比以往任何时候都更加重要。复杂性不仅增加了系统的维护成本，更可怕的是，它像隐形的时间炸弹，随时可能引发灾难性的系统故障。2012年，骑士资本集团因部署错误的软件更新导致4.6亿美元损失；
2025-11-06 07:00:00
1197
原创 MySQL存储架构解析：从数据无序到索引艺术的演进
在当今数据驱动的时代，高效的数据存储和检索已成为互联网应用的基石。作为最流行的开源关系型数据库之一，MySQL的存储架构设计体现了数十年数据库理论的精华。想象一下，如果没有良好的存储结构，查询一个拥有百万条记录的用户表就像在一间杂乱无章的仓库中寻找特定物品，而优秀的存储架构则像为仓库建立了精密的货架系统和检索目录。本文将深入解析MySQL的存储架构设计，重点探讨其核心——B+树索引结构。通过追溯技术演进历程、分析实际案例和代码示例，揭示MySQL如何高效管理数据存储，以及这种设计背后的深层原理。
2025-11-05 12:45:00
1202
原创 MySQL存储引擎深度解析：从MyISAM到InnoDB的技术演进与实践
存储引擎是数据库管理系统中负责数据的存储、检索和管理的组件。在MySQL中，存储引擎处于文件系统之上，负责在数据库和物理存储之间进行数据转换。-- 查看MySQL支持的存储引擎-- 查看当前数据库的存储引擎。
2025-11-05 07:00:00
1753
原创 MySQL写入SQL执行全链路解析：从客户端到磁盘的深度剖析
MySQL的写入SQL执行流程是一个复杂而精妙的系统工程，它涉及客户端通信、SQL解析、查询优化、存储引擎、内存管理、日志系统等多个组件的协同工作。分层架构：MySQL采用清晰的分层架构，每层职责单一，便于理解和优化日志先行：通过Redo Log、Undo Log、Binlog等多重日志机制保证数据安全内存优化：Buffer Pool等内存结构大幅提升了数据库性能异步处理：合理的异步化设计平衡了性能和数据一致性可配置性：丰富的配置参数支持不同业务场景的调优。
2025-11-04 12:45:00
1107
原创 MySQL查询SQL执行全链路解析：从网络包到结果集的深度之旅
通过本文的详细解析，我们深入了解了MySQL查询SQL从客户端提交到结果返回的完整过程。客户端层：SQL生成、协议封装、连接管理服务端连接层：身份验证、连接池、线程管理SQL处理层：解析、优化、执行计划生成存储引擎层：数据访问、索引管理、事务支持结果返回层：流式传输、协议编码、客户端处理理解这个完整流程对于数据库性能优化、故障排查和架构设计都具有重要意义。合理设计查询：避免SELECT *，使用合适的WHERE条件优化索引策略：创建覆盖索引，避免索引失效监控执行计划：定期分析慢查询，优化执行路径。
2025-11-04 07:00:00
1161
原创 MySQL事务日志深度解析：Undo Log与Redo Log的协同设计奥秘
MySQL的事务日志系统是一个精心设计的架构奇迹，Undo Log和Redo Log各司其职又紧密配合，共同保障了数据库的ACID特性。Undo Log主要负责维护事务的原子性和隔离性，通过记录数据修改前的状态，支持事务回滚和MVCC机制。其精巧的回滚段设计和版本链管理，使得读不阻塞写、写不阻塞读成为可能，极大地提升了系统的并发性能。Redo Log则确保了事务的持久性，采用WAL策略和Log Block设计，既保证了数据安全，又通过顺序写入优化了IO性能。
2025-11-03 12:45:00
1830
原创 Kubernetes基于主机和路径路由的蓝绿部署创新设计
Kubernetes基于主机和路径路由的蓝绿部署代表了现代应用部署的最佳实践。通过精细的流量控制能力，它成功解决了传统部署策略中的停机时间和发布风险问题。业务价值真正实现用户无感知的零停机部署大幅降低发布风险，提升业务连续性支持快速迭代，加速产品创新技术优势灵活的流量控制策略细粒度的版本管理快速的回滚能力完善的监控观测运维效益标准化的发布流程自动化的运维操作降低人为错误概率。
2025-11-03 07:00:00
1255
原创 MySQL慢查询日志智能分析：基于Elasticsearch的可视化架构设计
"name": "慢查询突增告警",},"input": {"body": {"size": 0,"query": {"range": {},"aggs": {},"gt": 100},"body": "{\"text\": \"过去5分钟检测到 {{ctx.payload.aggregations.slow_query_count.value}} 个慢查询，请及时处理！\"}"
2025-10-31 07:00:00
1331
原创 大模型部署的革命：从单机到云原生的架构演进与实践
随着大模型技术的不断发展，部署技术也在快速演进。边缘推理的兴起：将小型化的大模型部署到边缘设备多模态模型部署：处理文本、图像、音频等多种输入类型实时学习与适应：模型能够在推理过程中持续学习绿色AI：更加注重能效和可持续性的部署方案大模型部署是一个复杂而富有挑战性的领域，涉及分布式系统、高性能计算、编译器优化等多个技术领域的深度融合。本文从技术演进的角度，系统地介绍了从单机部署到云原生架构的完整发展历程。通过生活化的案例、详细的代码示例和专业的架构分析，我们展示了现代大模型部署的核心技术和最佳实践。
2025-10-30 12:45:00
943
原创 深入解析与修复KeyError: ‘model‘：数据科学工程中的关键错误处理
KeyError是Python中字典(Dict)操作时常见的异常类型，当尝试访问字典中不存在的键时便会触发。在数据科学工程环境中，这一错误的出现频率和影响范围往往超出预期，主要原因在于：数据科学工作流中大量使用字典结构存储配置、参数和中间结果机器学习模型序列化与反序列化过程中键值匹配的复杂性分布式计算环境中数据一致性问题导致的键丢失多版本模型部署时的兼容性问题# 错误的序列化实现：遗漏关键字段# 反序列化时'model'键不存在"""提供详细访问日志的字典类"""})})
2025-10-30 07:00:00
931
原创 机器学习全流程深度解析：从原始数据到智能部署
数据质量决定模型上限：没有高质量的数据，再先进的算法也无法发挥价值特征工程是艺术与科学的结合：需要领域知识和数据洞察模型训练需要理论与实践平衡：理解算法原理同时关注实际效果评估验证确保模型可靠性：全面的评估体系是模型可信的保障部署监控实现价值闭环：只有部署到生产环境才能创造实际价值。
2025-10-29 12:45:00
934
原创 分布式系统数据一致性演进：从ACID到BASE的理论突破与实践创新
在当今互联网时代，随着业务规模的不断扩大和用户量的持续增长，传统的单机数据库系统已无法满足高并发、高可用的需求。分布式系统成为必然选择，而数据一致性这一核心问题也随之变得异常复杂。ACID与BASE作为两种截然不同的数据一致性模型，分别代表了传统数据库设计与现代分布式系统设计的核心理念。作为架构师，我们面临着如何在保证系统可用性的同时，维护数据一致性的挑战。本文将深入探讨ACID与BASE的理论基础、演进历程，并通过实际案例和代码示例，展示如何在现代分布式系统中合理选择和结合这两种模型。
2025-10-29 07:00:00
592
原创 UUIDv7 主键革新：构建高并发分布式系统的时序标识方案
性能优异：时序特性大幅提升了数据库索引性能分布友好：天然支持分布式系统，无需中心化ID生成器安全可靠：不暴露业务信息，难以预测运维简单：无需维护复杂的ID生成基础设施。
2025-10-28 12:30:00
1054
原创 现代软件部署架构演进与创新设计：从标准部署到智能渐进式交付
在互联网应用快速迭代的今天，部署策略已经从简单的运维操作演变为影响业务连续性的核心架构要素。传统部署方式在面对大规模分布式系统时显得力不从心，本文将深入剖析标准部署、蓝绿部署、金丝雀部署等主流部署架构的设计原理，并探讨其创新演进路径。
2025-10-28 07:00:00
946
原创 现代软件部署策略全景解析：从标准部署到蓝绿与金丝雀部署
部署策略核心思想适用场景关键考量标准部署原地更新，简单直接非核心应用、内部系统、开发测试环境部署停机可接受，资源紧张蓝绿部署维护双环境，瞬时切换对可用性要求极高的关键业务，要求快速回滚资源成本，数据兼容性金丝雀部署小流量试点，逐步放量面向公众的大型应用，需要观察真实用户反馈流量控制能力，监控成熟度滚动部署逐实例更新，零停机容器化、微服务架构，资源受限但需高可用版本兼容性，回滚速度功能开关代码与发布解耦所有策略的补充，用于特性灰度、A/B测试代码管理，开关生命周期管理。
2025-10-27 12:30:00
754
原创 解读运维四大关键指标：MTTR、MTTA、MTTF、MTBF
对于一个不可修复的产品或组件，从它开始运行到它发生第一次故障的平均时间。它本质上预测的是产品的“寿命终点”。
2025-10-24 07:00:00
1019
原创 构筑智能防线：DevSecOps安全工具金字塔
每一次向上，都代表着安全能力的质变——从孤立的工具，到集成的流程，最终升华为一种智能、自适应的安全文化。在这条路上，工具是载体，而人与流程的进化，才是通往卓越安全的真正密钥。在数字化浪潮席卷全球的今天，安全不再是软件开发生命周期（SDLC）末尾的“检查站”，而是贯穿始终的“基石”。：将保护逻辑像“疫苗”一样注入到应用中，使应用在运行时能够自我识别并阻断攻击，是内生的、自适应的安全能力。，将下层所有工具和数据整合，实现安全工作的平台化、智能化运营，达到持续自适应安全的最高境界。
2025-10-23 12:45:00
1465
菜鸟取经·程序员面试（第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关注的人