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

Other Books You May Enjoy