系统架构设计师考试32小时通关-第2版

# 系统架构设计师考试32小时通关-第2版 — Reading Guide ## 【One-Line Pitch】 A tightly structured exam-prep manual that compresses the entire System Architecture Designer certification syllabus into 32 one-hour sessions, covering everything from computer fundamentals to cloud-native and embedded architecture. Ideal for candidates who want a focused, high-yield review path with practice questions and exam-strategy tips baked into every chapter. --- ## 【Book Arc】 - **Opening (~0%–10%)**: Computer system fundamentals — hardware, buses, interfaces, UML modeling, and embedded system basics. Establishes the vocabulary and core concepts that later architecture discussions build on. - **Early (~10%–30%)**: Network protocols, information security threats and defenses, system performance metrics, software engineering lifecycle models, and database design theory — including relational algebra, NoSQL categories, and Redis caching mechanics. - **Middle (~30%–50%)**: Architecture design fundamentals — quality attributes, evaluation methods (SAABNet, SACMM, SASAM, ALRRA), software reliability modeling, architecture evolution and maintenance, plus the ten-stage evolution of large website architectures from monolith to distributed services. - **Middle (~50%–70%)**: Practical architecture design — layered architecture, transaction design, IoT layered architecture, cloud-native architecture (containers, event-driven patterns, anti-patterns), and SOA design patterns including service registries, enterprise service buses, and microservices. - **Late (~70%–100%)**: Specialized architecture domains — embedded system architecture, communication system architecture, and security architecture, followed by exam-style practice questions and answer analyses. --- ## 【Key Takeaways】 - **UML provides a standardized visual language for architecture** (Early): Four types of things (structural, behavioral, grouping, annotational) and four relationships (dependency, association, generalization, realization) form the backbone of architecture documentation. Understanding the distinction between aggregation (parts can outlive the whole) and composition (parts die with the whole) is a frequent exam point. - **Embedded systems are resource-constrained, safety-critical, and require cross-compilation** (Early): Unlike general-purpose computers, embedded systems feature dedicated hardware, ROM-coded programs, and real-time requirements. The host-target development model with cross-compiler toolchains is a core concept — the host machine (PC) compiles code for the target machine (embedded device) when their instruction sets differ. - **Network security defense requires understanding attack mechanisms first** (Early): ARP spoofing, DNS spoofing, IP spoofing, port scanning, SYN flooding, and ICMP attacks each exploit specific protocol weaknesses. Defense strategies include ARP table hardening, protocol upgrades, firewalls, and patch management — knowing the attack vector is half the defense. - **Performance evaluation uses both formula-based and measurement-based approaches** (Early): MIPS, theoretical floating-point peak, and Gibson's method (weighted instruction times) provide quantitative measures. Performance tuning is fundamentally bottleneck identification and elimination — for databases, this means examining CPU/memory usage, I/O, and log file sizes. - **Software lifecycle models trade off risk management against process rigidity** (Early): The waterfall model is simple but inflexible; the prototype model addresses unclear requirements (with throwaway vs. evolutionary variants); the spiral model adds explicit risk analysis at each phase. Choosing the right model depends on project uncertainty and scale. - **Database design theory centers on functional dependencies and normalization** (Early): Relational algebra operations (select, project, join, divide) and the distinction between trivial/non-trivial and full/partial functional dependencies underpin schema design. NoSQL databases trade ACID guarantees for scalability, with columnar, key-value, document, and graph stores each suited to different data shapes. - **Redis caching requires deliberate consistency and eviction strategies** (Middle): Read/write patterns must handle cache-miss flows and data synchronization between cache and database. Expiration uses periodic random deletion plus lazy deletion, while eviction policies (LRU, LFU, random, TTL-based) manage memory pressure — and persistence mechanisms protect against data loss on server failure. - **Architecture evolution follows a predictable ten-stage progression** (Middle): From monolith → vertical split → caching → clustering → read/write separation → CDN/reverse proxy → distributed storage → NoSQL/search → business splitting → distributed services. This staged model is both an exam favorite and a practical roadmap for scaling real systems. - **Cloud-native architecture has identifiable anti-patterns** (Middle): Monolithic apps lack dependency isolation; "hard-splitting" monoliths into microservices creates distributed-call performance problems; microservices without automation increase per-developer workload. Containers solve environment consistency by packaging applications with all dependencies. - **SOA and microservices share core principles but differ in granularity** (Middle): Both emphasize loose coupling, reusability, and interoperability. Service registries enable discovery and binding; enterprise service buses provide message routing, protocol transformation, and monitoring; microservices push decomposition further with independent deployment and technology flexibility. --- ## 【Reading Tips】 - **Skim the "考点分析" (exam point analysis) sections first** — each hour opens with a breakdown of how the topic appears on the exam (single-choice, case study, or essay). This tells you where to invest deep study vs. light review. - **Deep-read the architecture evolution chapter (Hour 12)** — the ten-stage website evolution model is a high-yield case-study topic that connects many isolated concepts (caching, clustering, CDN, NoSQL) into one coherent narrative. - **Practice the calculation problems actively** — performance metrics (MIPS, floating-point peak), break-even analysis, and Gibson's method require formula application, not just memorization. Work through the practice questions with answer explanations rather than reading them passively. - **Pay attention to comparison tables** — the book frequently uses tables (e.g., DNS iterative vs. recursive queries, Redis eviction policies, NoSQL categories) that compress large amounts of examinable detail into scannable form. These are prime memorization targets. - **Treat the embedded and communication chapters as optional depth** — the book itself notes embedded content is "偏" (off-center) and appears as elective case-study questions. If time is tight, prioritize the core architecture, database, and cloud-native chapters instead. --- ## 【Coverage Limits】 This guide synthesizes the first ~50% of the book in detail (fundamentals through SOA/cloud-native), with lighter coverage of the later specialized chapters (embedded, communication, security architecture) and the final exam simulation sections. The excerpts do not include the book's video course content or full practice exam sets. --- ##