Overview

Continuous Enterprise Development in Java, subtitled “Testable Solutions with Arquillian,” is aimed at Java EE developers who want to build, test, and continuously deliver enterprise applications. The book is logically divided into two distinct parts: a foundational section covering concepts and tooling, and an implementation-focused section that walks through building a full JEE application layer by layer.

Part One: Foundations (Chapters 1–4)

The opening chapters establish context before any code appears. Topics covered include:

• The inherent difficulties of testing Java EE (JEE) applications in realistic container environments
• Software development lifecycle concepts and the role of continuous integration
• Types of testing — unit, integration, and end-to-end — and when each applies
• Testing frameworks: JUnit and TestNG
• Build tooling: Maven and JBoss Forge
• Version control: Git receives a dedicated section, though other VCS tools are not covered
• A thorough introduction to Arquillian, described in the book as “an innovative and highly extensible testing platform for the JVM”

ShrinkWrap: Programmatic JEE Archives

One of the stronger introductory sections covers ShrinkWrap, an API that lets developers create deployable JEE archives — JARs, WARs, and EARs — programmatically at test time. This removes the need to maintain separate deployment descriptors just for testing and is central to how Arquillian manages in-container test deployments.

Chapter 3: Writing and Deploying with Arquillian

An entire chapter is dedicated to writing business code alongside its Arquillian integration tests and deploying the result. The toolchain used throughout this chapter leans heavily on the Red Hat ecosystem:

• JBoss Forge for scaffolding and building the application
• JBoss Application Server for local deployment
• JBoss Developer Studio for deployment to Red Hat’s OpenShift cloud platform

Readers who prefer vendor-agnostic tooling may find this chapter limiting, as the examples are tightly coupled to JBoss and Red Hat products.

Part Two: Building the JEE Application (Chapters 5–12)

The second half of the book is structured around building a complete JEE application, with each chapter tackling one architectural layer or concern:

• Chapter 5 — Persistence layer (JPA and relational data)
• Chapter 6 — Integration with NoSQL databases
• Chapter 7 — Services layer (EJBs and CDI)
• Chapter 8 — REST services
• Chapter 9 — Security
• Chapter 10 — User interface
• Chapter 11 — Live deployment

Consistent Chapter Structure

Each chapter in Part Two follows a repeatable pattern, which makes the book easy to navigate as a reference:

1. Technology introduction — a concise explanation of the JEE component or API being used
2. Use cases and business requirements — what the application needs to do
3. Implementation — code walkthroughs for the feature
4. Testing with Arquillian — integration tests that validate the implementation inside a real container

This four-step rhythm is one of the book’s structural strengths, making it straightforward to find where implementation ends and testing begins.

What Works Well

• Strong JEE coverage: The author demonstrates clear command of JEE components. The technology introductions in Part Two are concise and accessible without being superficial.
• Deep Arquillian expertise: All Arquillian examples are well-explained, and the ShrinkWrap introduction in particular is a highlight of the book.
• Valuable external references: Certain chapters point readers to authoritative external resources. The security chapter references PicketLink, and the REST chapter references the Richardson Maturity Model — both useful for developers who want to go deeper.

Limitations and Criticisms

• Heavy Red Hat / JBoss bias: The book’s examples are almost exclusively tied to JBoss and Red Hat tooling. Developers working with other application servers or build tools will need to mentally translate much of the practical content.
• Subtitle vs. content mismatch: The subtitle promises a focus on “Testable Solutions with Arquillian,” but the book devotes substantial space to application development concepts in general. Arquillian-specific testing is only one thread running through the book rather than its central focus.
• No coverage of non-JEE frameworks: The book does not address how Arquillian integrates — or whether it integrates usefully — with popular non-JEE frameworks such as Spring or Google Guice. This is a significant gap for teams whose codebases mix JEE and non-JEE components.

Who Should Read This Book

This book is best suited for Java EE developers who are already working within or comfortable adopting a JBoss/Red Hat stack and want a practical guide to adding Arquillian-based integration testing to their workflow. It is less useful as a general Arquillian reference for developers working outside the JEE ecosystem or those on alternative application servers.

If your team is already invested in JEE and wants to understand how to continuously develop and test enterprise applications end-to-end — from the persistence layer through to live deployment — this book provides a coherent, well-structured path to get there.