Architecting Modern Java EE Applications · Designing Lightweight, Business-Oriented Enterprise Applications in the Age of Cloud, Containers, and Java EE 8 by Daschner, Sebastian -- Read -- Imperial Library of Trantor

Index

Title Page Copyright

Architecting Modern Java EE Applications

Credits Foreword About the Author Acknowledgments About the Reviewer www.PacktPub.com

Why subscribe?

Customer Feedback Dedication Preface

What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support

Downloading the example code Errata Piracy Questions

Introduction

New demands in enterprise systems Modern way of realizing enterprise systems Relevance of Java EE in modern systems Java EE 8 update and roadmap Java Community Process What to expect in the book

Designing and Structuring Java Enterprise Applications

The purpose of enterprise applications

What developers should focus on Meeting customer's demands

Outer enterprise project structure

Business and team structures Software projects contents

Application source code Software structures Version control systems Binaries Build systems

Single versus multi-module projects Illusion of reusability

Technical dependencies Organizational challenges Reusability considerations

Project artifacts One project per artifact Build systems for Java EE

Apache Maven Gradle

Structuring for modern frontend technologies

Enter JavaScript frameworks Organizing modern frontends

Enterprise project code structure

Situation in enterprise projects Horizontal versus vertical layering Business-driven structure Designing reasonable modules Realizing package structures

Package contents Horizontal package layering Flat module package Entity Control Boundary

Packages Package access

Don't over-enforce architecture

Summary

Implementing Modern Java Enterprise Applications

Use case boundaries Core domain components of modern Java EE

EJB and CDI - differentiation and integration CDI producers Emitting domain events Scopes

Patterns in Java EE

Design patterns revisited

Singleton Abstract factory Factory method Object pool Decorator Facade Proxy Observer Strategy Further patterns

Domain-Driven Design

Services Entities Value objects Aggregates Repositories Factories Domain event

External and cross-cutting concerns in enterprise applications

Communication with external systems

How to choose communication technology Synchronous HTTP communication

Representational State Transfer Java API for RESTful web services Mapping HTTP content types Validating requests Mapping errors Accessing external systems Stability when consuming HTTP Accessing Hypermedia REST services

Asynchronous communication and messaging

Asynchronous HTTP communication Message-oriented communication Server-sent events WebSocket

Connecting enterprise technology

Database systems

Integrating RDBMS systems

Mapping domain models Integrating database systems Transactions

Relational databases versus NoSQL

Cross-cutting concerns Configuring applications Caching

Flow of execution

Synchronous execution Asynchronous execution

Asynchronous EJB methods Managed Executor Service Asynchronous CDI events Scopes in asynchronicity Timed execution Asynchronous and reactive JAX-RS

Concepts and design principles of modern Java EE Preserving maintainable code with high quality Summary

Lightweight Java EE

Lightweight enterprise technology Why Java EE standards? Convention over configuration Dependency management of Java EE projects Lightweight way of packaging applications Java EE application servers One application per application server Summary

Container and Cloud Environments with Java EE

Motivations and goals

Infrastructure as code Stability and production readiness

Containers Java EE in the container Container orchestration frameworks Realizing container orchestration Java EE in orchestrated containers

Connecting external services Configuring orchestrated applications

12-factor applications and Java EE

Have one codebase tracked in revision control, many deploys Explicitly declare and isolate dependencies Store config in the environment Treat backing services as attached resources Strictly separate build and run stages Execute the app as one or more stateless processes Export services via port binding Scale out via the process model Maximize robustness with fast startup and graceful shutdown Keep development, staging, and production as similar as possible Treat logs as event streams Run admin/management tasks as one-off processes

Cloud, Cloud native, and their benefits

Cloud native

Summary

Application Development Workflows

Motivation and goals of productive development workflows Realizing development workflows

Version control everything Building binaries

Java artifacts Artifact versions Building containers

Quality assurance Deployment

Configuration Credentials

Data migration

Adding database structures Changing database structures Removing database structures Implementing migration

Testing Build metadata Going to production Branching models Technology Pipeline-as-code

Workflows with Java EE Continuous Delivery culture and team habits

Responsibility Check in early and often Immediately fixing issues Visibility Improve continuously

Summary

Testing

The necessity of tests Requirements of well-crafted tests

Predictability Isolation Reliability Fast execution Automation Maintainability

What to test Definition of test scopes

Unit tests Component tests Integration tests System tests Performance tests Stress tests

Implementing tests

Unit tests

Implementation Technology

Component tests

Motivation Implementation Delegating test components Technology

Integration tests

Embedded containers Embedded databases Running integration tests

Code level integration tests versus system tests

Shortcomings of integration tests Shortcomings of system tests Conclusion

System tests

Managing test scenarios Simulating external concerns Designing system tests

Deploying and controlling external mocks

Performance tests

Motivation Key performance indicators Developing performance tests Insights

Running tests locally Maintaining test data and scenarios

Importance of maintainable tests Signs of lack of test quality Test code quality Test technology support

Summary

Microservices and System Architecture

Motivations behind distributed systems Challenges of distribution

Communication overhead Performance overhead Organizational overhead

How to design systems landscapes

Context maps and bounded contexts Separation of concerns Teams Project life cycles

How to design system interfaces

API considerations Interface management

Change-resilient APIs Breaking the business logic Hypermedia REST and versioning

Documenting boundaries Consistency versus scalability

Event sourcing, event-driven architectures, and CQRS

Shortcomings of CRUD-based systems

Scalability Competing transactions Reproducibility

Event sourcing

Benefits

Eventually consistent real world Event-driven architectures

Eventual consistency in event-driven architectures

Enter CQRS

Principles Design Benefits Shortcomings

Communication Microservice architectures

Sharing data and technology in enterprises Shared-nothing architectures Interdependent systems 12-factor and cloud native applications When to use and when not to use microservices

Implementing microservices with Java EE

Zero-dependency applications Application servers Implementing application boundaries Implementing CQRS

System interfaces Example scenario using Apache Kafka Integrating Java EE

CDI events Event handlers State representation Consuming Kafka messages Producing Kafka messages Application boundaries

Integrating further CQRS concepts

Java EE in the age of distribution

Discovering services Communicating resiliently

Validating responses Breaking timeouts and circuits Bulkheads Shaking hands and pushing back