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

Hands-On Software Architecture with Java
Contributors
About the author
About the reviewer
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share your thoughts
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
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share your thoughts