What this book covers
Chapter 1, Diving into Software Architecture, explores the fundamentals of software architecture, distinguishing it from design. It introduces architectural principles, styles such as monolithic and microservices, and the CAP theorem, offering guidance on aligning technical requirements with business goals and choosing databases to support different architectural needs.
Chapter 2, Decision-Making Processes in Software Architecture, highlights the importance of architectural decisions. It covers key choices, trade-offs, and systematic methods such as ATAM. The chapter emphasizes aligning decisions with business goals, documenting them with ADRs, and using case studies to demonstrate the impact of thoughtful, collaborative decision-making.
Chapter 3, Understanding the System Context, explores the distinction between system context and architecture, emphasizing their integration into design. It covers stakeholder engagement, functional and non-functional requirements, and agile methodologies for dynamic management. It also introduces the C4 model for clear, hierarchical documentation, enhancing communication, and architectural visualization.
Chapter 4, Monolithic Architecture, explores monolithic architecture, detailing its definition, pros and cons, and patterns such as N-Layer and MVC. It explains stateful and stateless operations and demonstrates implementing a monolithic application with Spring Boot, Spring Web MVC, Thymeleaf, and Spring Security, using an online auction system as a case study. It also emphasizes automated testing.
Chapter 5, Client-Server Architecture, explores client-server architecture and its components. It covers RESTful API design and token-based authentication using JWT. A case study transitions the monolithic auction application to a client-server architecture, demonstrating API documentation using OpenAPI, security, and testing practices such as code coverage testing with JaCoCo.
Chapter 6, Microservices Architecture, highlights microservices’ autonomy and specialization, along with their benefits and challenges. It focuses on transitioning the online auction application to microservices. It explores domain-driven design (DDD), CAP theorem-driven database strategies, clean architecture, monitoring with Spring Boot Actuator, and containerizing microservices using Docker and Docker Compose.
Chapter 7, Microservices Patterns with Spring Cloud, explores patterns such as service discovery, load balancing, centralized configuration, gateways, and resilience with Spring Cloud tools.
Chapter 8, Event-Driven Architecture, examines event-driven systems and their asynchronous nature. It covers essential components, event types, and patterns. The chapter concludes with an implementation using Apache Kafka for message handling in an online auction application.
Chapter 9, Pipe-and-Filter and Serverless Architecture, examines modular workflows with pipe-and-filter patterns and implements them using Spring Batch. It also explores serverless architecture with FaaS solutions, using Spring Cloud Functions to run and deploy the application locally and in AWS Lambda.
Chapter 10, Security, emphasizes integrating security from the start, covering encryption, authentication, authorization, and safeguarding data at rest and in transit. It addresses threats such as DoS, input injection, CSRF, and XSS alongside defense mechanisms. It introduces frameworks such as Zero Trust Architecture, threat modeling, and OWASP and provides an in-depth discussion of OAuth2 and OpenID Connect with practical steps for implementing authentication and authorization.
Chapter 11, Observability, introduces logs, metrics, and traces for system reliability and explores and presents tools such as APM, ELK, OpenTelemetry, and Zipkin for distributed tracing, centralized logging, and metric collection in modern architectures.
Chapter 12, Testing, emphasizes quality assurance, showcasing how automated testing ensures faster, more reliable releases. It explores the testing pyramid, covering unit, integration, and UI tests, and tools such as Testcontainers for stable, dependency-free tests. The chapter also highlights performance testing and delves into TDD and BDD, demonstrating their role in improving code quality and aligning tests with business requirements.
Chapter 13, Performance and Optimizations, discusses enhancing application efficiency and scalability through JVM architecture and Garbage Collector tuning. It offers strategies for heap size configuration to reduce latency and improve throughput and caching techniques to boost performance and reduce server load. The chapter also introduces reactive programming with Spring WebFlux.
Chapter 14, Orchestration with Kubernetes, introduces Kubernetes for containerized application management. It covers cluster components, deployment manifests, and practical guidance for deploying services in a scalable, self-healing environment.
Chapter 15, Continuous Integration and Continuous Deployment, explores the concepts of CI/CD and guides the construction of Jenkins pipelines for automated integration, testing, and deployment. Practical steps include Docker containerization, GitHub integration, and application deployment to a Kubernetes environment using Minikube.
