EN
RU
ES
ZH
FR
DE
PT
AR
HI
The Java EE Architect's Handbook
The Java EE Architect's Handbook
Summary:
Introduction
The book "The Java EE Architect's Handbook" (2014) by Derek Ashmore is not another API reference or framework tutorial. It is the concentrated experience of an architect who has designed enterprise systems on Java EE for decades. Unlike many books that focus on implementation details, Ashmore raises strategic choice questions: which version of Java EE to use, how to organize modules, how to ensure scalability and fault tolerance. For the educational site PythonLib, this review will help readers understand whether it is worth spending time on this book, even if their primary language is Python, since architectural principles are universal.
What the book is about
The book consists of 12 chapters, each dedicated to a key aspect of Java EE architecture. The author starts with the basics: what Java EE is, which components are included in the specification (EJB, JPA, JMS, Servlets, etc.) and how they interact. Then he moves on to practical topics:
- Choosing an application server — comparison of WebLogic, WebSphere, JBoss, GlassFish, and TomEE.
- Designing layers — presentation, business, persistence, integration.
- Transaction management — container-managed and bean-managed transactions.
- Security — authentication, authorization, SSL, JAAS.
- Scaling and clustering — horizontal and vertical scaling, session replication.
- Integration with legacy systems — JMS, JCA, web services.
- Testing and performance — profiling, load testing, optimization.
Special attention is given to antipatterns and typical mistakes that even experienced developers make.
Who this book is for
The book is intended for Senior and Team Lead Java developers who already have experience building web applications on Java EE (or Spring) and want to transition to an architect position. It will also be useful for technical managers who make decisions about choosing a technology stack. Beginners will find the book challenging — knowledge of Java EE basics (JPA, EJB, Servlets) is assumed. For Python developers interested in enterprise architecture, the book will provide an understanding of how large Java projects are structured and help transfer best practices to their own stack (e.g., Django + Celery + PostgreSQL).
What the reader will learn
- How to choose between EJB 2.x and EJB 3.x — the author explains why outdated approaches should be avoided.
- How to design modules — splitting into JAR, WAR, EAR, dependency management.
- How to ensure fault tolerance — configuring clusters, session replication, failure handling.
- How to integrate Java EE with external systems — via JMS, REST, SOAP.
- How to test architecture — unit tests, integration tests, performance tests.
- How to document architectural decisions — ADR (Architecture Decision Records) templates.
- How to avoid vendor lock-in — using standard APIs instead of proprietary extensions.
Strengths
The main advantage of the book is its practical focus. Ashmore doesn't just list Java EE features; he gives specific advice based on real projects. For example, he thoroughly explains why Stateful Session Beans should not be used in a clustered environment and offers alternatives. The second strength is the emphasis on non-functional requirements: performance, security, scalability. The third is vendor neutrality: the author compares application servers without bias, pointing out the pros and cons of each. Finally, the book is written in a lively language
Recommendations