Key Features
------------
Understand the fundamentals of software architecture and build production-grade applications in Java
Make smart architectural decisions with comprehensive coverage of various architectural approaches from SOA to microservices
Gain an in-depth understanding of deployment considerations with cloud and CI/CD pipelines
Book Description
----------------
Well-written software architecture is the core of an efficient and scalable enterprise application. Java, the most widespread technology in current enterprises, provides complete toolkits to support the implementation of a well-designed architecture.
This book starts with the fundamentals of architecture and takes you through the basic components of application architecture. You'll cover the different types of software architectural patterns and application integration patterns and learn about their most widespread implementation in Java. You'll then explore cloud-native architectures and best practices for enhancing existing applications to better suit a cloud-enabled world. Later, the book highlights some cross-cutting concerns and the importance of monitoring and tracing for planning the evolution of the software, foreseeing predictable maintenance, and troubleshooting. The book concludes with an analysis of the current status of software architectures in Java programming and offers insights into transforming your architecture to reduce technical debt.
By the end of this software architecture book, you'll have acquired some of the most valuable and in-demand software architect skills to progress in your career.
What you will learn
-------------------
Understand the importance of requirements engineering, including functional versus non-functional requirements
Explore design techniques such as domain-driven design, test-driven development (TDD), and behavior-driven development
Discover the mantras of selecting the right architectural patterns for modern applications
Explore different integration patterns
Enhance existing applications with essential cloud-native patterns and recommended practices
Address cross-cutting considerations in enterprise applications regardless of architectural choices and application type
Who this book is for
--------------------
This book is for Java software engineers who want to become software architects and learn everything a modern software architect needs to know. The book is also for software architects, technical leaders, vice presidents of software engineering, and CTOs looking to extend their knowledge and stay up to date with the latest developments in the field of software architecture.
Author(s): Giuseppe Bonocore
Edition: 1
Publisher: Packt
Year: 2022
Language: English
Pages: 510
Tags: java java17 jdk openjdk uml architexture software engineering design analysis
Cover
Title Page
Copyright
Contributors
Table of Contents
Preface
Section 1: Fundamentals of Software Architectures
Chapter 1: Designing Software Architectures in Java – Methods and Styles
The importance of software architecture
The objectives of architecture design in the software life cycle
The software architect – role and skills
Is architecture design still relevant in modern development?
Different types of architecture design – from doodling on paper to more accurate modeling
Sketching the main architectural components
Other kinds of architectural diagrams
Common types of architectural diagrams
The changing role of Java in cloud-native applications
Why Java technology is still relevant today
Java usage in enterprise environments
JEE evolution and criticism
Introducing cloud-native Java
The Java microservices ecosystem
Case studies and examples
Case study – mobile payments
Whiteboarding the overall architecture
Software components diagram
Summary
Further reading
Chapter 2: Software Requirements – Collecting, Documenting, Managing
Introducing requirements engineering
Feature, Advantage, and Benefit
Features and technical requirements
Types and characteristics of requirements
The life cycle of a requirement
Discovering and collecting requirements
The lean canvas
Event Storming
More discovery practices
Analyzing requirements
Checking for coherence and feasibility
Checking for explicitness and testability
Checking non-functional requirements and constraints
Specifying requirements according to the IEEE standard
The 830-1998 standard
The 29148 standard
Collecting requirements – formats and tools
Software requirements data to collect
Collecting software requirements in spreadsheets
Specialized tools for software requirements management
Spreadsheets versus tools
Validating requirements
Case studies and examples
The mobile payment application example
Event Storming for peer-to-peer payments
Requirements spreadsheet
Summary
Further reading
Chapter 3: Common Architecture Design Techniques
Introducing marchitectures – impactful and purely demonstrative schemas
Familiarizing ourselves with UML notation
Understanding the background to UML
Class diagrams
Sequence diagram
Wrapping up on UML
Exploring ArchiMate
The ArchiMate Core and Full Frameworks
Navigating the ArchiMate language tree
Comparing ArchiMate to UML
Comparing ArchiMate to TOGAF
Introducing the C4 model
Exploring the C4 model
Filling in the different levels
Other modeling techniques
BPMN
DMN
arc42
Case studies and examples
UML class diagrams for mobile payments
C4 diagrams for mobile payments
Summary
Further reading
Chapter 4: Best Practices for Design and Development
Understanding Domain Driven Design
The anemic domain model
Understanding ubiquitous language
Getting familiar with layered architecture
Learning about the domain model
Glancing at DDD patterns
Bounded Context
Introducing Test Driven Development
Exploring Behavior Driven Development
Comparing DDD, TDD, and BDD
Learning about user story mapping
The MVP
Case studies and examples
The mobile payments domain model
The layered architecture of mobile payments
BDD of mobile payments
User story mapping of mobile payments
Summary
Further reading
Chapter 5: Exploring the Most Common Development Models
Learning about Code and Fix
Glancing at the Waterfall model
Advantages and disadvantages of the Waterfall model
Understanding the Agile methodology
The Agile principles
Introducing Lean software development
Eliminating waste
Deciding as late as possible
Delivering as fast as possible
Optimizing the whole product
Pros and cons of Lean development
Exploring Scrum
Understanding the Scrum teams
Learning about Scrum Events
Understanding Scrum artifacts
Advantages and disadvantages of Scrum
Learning about other Agile practices
Kaizen
Planning Poker
Kanban board
Burndown chart
Understanding DevOps and its siblings
DevOps team size
Roles and responsibilities in a DevOps team
Devs, Ops, and more
DevOps and the bigger organization
Pros and cons of DevOps
Case studies and examples
Summary
Further reading
Section 2: Software Architecture Patterns
Chapter 6: Exploring Essential Java Architectural Patterns
Encapsulation and hexagonal architectures
Hexagonal architectures and Domain Driven Design
Encapsulation and microservices
Learning about multi-tier architectures
Exploring Model View Controller
Server-side MVC
Client-side MVC
Diving into event-driven and reactive approaches
Defining events, commands, and messages
Introducing the event-driven pattern and event-driven architecture
Designing for large-scale adoption
Defining performance goals
Stateless
Data
Scaling
Case studies and examples
Encapsulating with a hexagonal architecture
Componentizing with multi-tier architecture
Planning for performance and scalability
Summary
Further reading
Chapter 7: Exploring Middleware and Frameworks
Technical requirements
Introducing the JEE standard
Diving into JEE implementations
Introducing the WildFly application server
Exploring the WildFly architecture
Running the WildFly server
Understanding the most common JEE APIs
Dependency injection
Jakarta RESTful Web Services
WebSocket
Messaging
Persistence
What's missing in Java EE
What's great about Java EE
Going beyond Java Enterprise Edition
Packaging microservices applications
Introducing MicroProfile
MicroProfile specifications
Exploring Quarkus
Better performances
Developer joy
Quarkus – hello world
Building techniques with Quarkus
Configuration management in Quarkus
Most common Quarkus extensions
Content Dependency Injection
REST services with JAX-RS
WebSockets
Messaging
Persistence
Accelerated ORM development with Panache
Quarkus and the MicroProfile standard
Case studies and examples
Summary
Further reading
Chapter 8: Designing Application Integration and Business Automation
Integration – point-to-point versus centralized
Understanding service-oriented architecture
Enterprise service bus – what and why?
Integration in the cloud-native world
Citizen integration
Digging into enterprise integration patterns
Message routing
Message transformation
System management
Messaging
Exploring formats
XML
JSON
Protobuf
Exploring communication protocols
SOAP and REST
gRPC
GraphQL
Introducing data integration
Completing the picture with business automation
Business rules
Business workflows
Integration versus automation – where to draw the line
Case studies and examples
Integrating payment capabilities
Automating customer onboarding
Summary
Further reading
Chapter 9: Designing Cloud-Native Architectures
Why create cloud-native applications?
Learning about types of cloud service models
Introducing containers and Kubernetes
Defining twelve-factor applications
Twelve-factor apps and the supporting technology
Well-known issues in the cloud-native world
Fault tolerance
Transactionality
Orchestration
Adopting microservices and evolving existing applications
Going beyond microservices
Miniservices
Serverless and Function as a Service
Refactoring apps as microservices and serverless
The five Rs of application modernization
The strangler pattern
Important points for application modernization
Summary
Further reading
Chapter 10: Implementing User Interaction
User interface architecture – backend versus frontend
Web user interface using Jakarta Server Pages and Jakarta Server Faces
Introducing basic Java web technology – Jakarta Server Pages
JSP – the downsides
Jakarta Server Faces – a complex JEE web technology
JSF – the downsides
Introducing single-page applications
Basics of the JavaScript ecosystem
Introducing the React framework
Learning about mobile application development
The importance of mobile applications
The challenges of mobile application development
Mobile application development options
Exploring IVR, chatbots, and voice assistants
Interactive voice response
Chatbots
Voice assistants
Omnichannel strategy in enterprise applications
Summary
Further reading
Chapter 11: Dealing with Data
Exploring relational databases
Keys and relationships
Transactionality
Stored procedures
Commonly used implementations of relation databases
Advantages and disadvantages of relational databases
Introducing key/value stores
Data caching techniques
Data life cycle
Commonly used implementations of key/value stores
The pros and cons of key/value stores
Exploring NoSQL repositories
The CAP theorem
NoSQL database categories
Looking at filesystem storage
The advantages and disadvantages of filesystems
Modern approaches – a multi-tier storage strategy
Summary
Further reading
Section 3: Architectural Context
Chapter 12: Cross-Cutting Concerns
Identity management
Authentication
Authorization
Identity and Access Management
Security
Intrinsic software security
Overall application security
Security standards and regulations
Resiliency
Uptime
Increasing system resiliency
Further techniques for improving reliability
Summary
Further reading
Chapter 13: Exploring the Software Life Cycle
Technical requirements
Source Code Management
Introducing Git
Testing
Unit testing
Beyond unit testing
Further testing considerations
Deploying
Building the code
Managing artifacts
Completing the deployment
Continuous integration/continuous delivery (and deployment)
Common CI/CD software implementations
Releasing
Maintenance
Summary
Further reading
Chapter 14: Monitoring and Tracing Techniques
Technical requirements
Log management
Common concepts in logging frameworks
Log aggregation
Collecting application metrics
Defining application health checks
Application Performance Management
Service monitoring
Summary
Further reading
Chapter 15: What's New in Java?
Java versioning
Vendor ecosystem
What's new in Java 17
Sealed classes
Pattern matching for switch statements
Strongly encapsulating JDK internals
More changes in Java 17
Summary
Further reading
Index
About Packt
Other Books You May Enjoy
