Preface
Software architecture is the cornerstone of software systems, shaping their scalability, performance, and maintainability. As software demands evolve, so does the need for flexible, efficient, and secure architectures. Spring Framework 6, with its comprehensive ecosystem and advanced features, serves as an excellent foundation for building scalable and resilient applications.
This book embarks on a journey through software architecture, starting with the fundamentals, introducing decision-making processes in software architecture, and exploring the importance of understanding the system context.
Using an online auction application as a case study, we evolve it through various architectural styles to reflect real-world software needs, addressing both functional and non-functional requirements. This approach ensures each concept is explained theoretically and brought to life through practical examples. You'll witness the application's transformation from a monolithic structure to distributed microservices and beyond, showcasing the progression of architectural decisions in modern software projects.
The book also delves into vital areas such as security, observability, testing, performance optimization, microservices orchestration, and CI/CD pipelines, providing a comprehensive toolkit for building enterprise-ready applications.
Who this book is for
This book is perfect for experienced Java software engineers aiming to become software architects or current architects looking to deepen their knowledge of software architecture styles using Spring 6.0.
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.
To get the most out of this book
To get the most out of this book, you should be familiar with Git and Maven, have basic knowledge of databases, Docker, and Docker Compose, be proficient in Java development with an object-oriented programming background, and have a solid understanding of the Spring Framework.
Software/hardware covered in the book
Operating system requirements
Java 21
Windows, macOS, or Linux
Maven 3.9.9
Windows, macOS, or Linux
Docker 27.4.0
Windows, macOS, or Linux
Docker Compose 2.32.2
Windows, macOS, or Linux
Git 2.39.5
Windows, macOS, or Linux
If you are using the digital version of this book, we advise you to type the code yourself or access the code from the book's GitHub repository (a link is available in the next section). Doing so will help you avoid any potential errors related to the copying and pasting of code.
Download the example code files
You can...
