Hands-On Software Architecture with Java - Learn key architectural techniques and strategies to design efficient and elegant Java applications

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