FOREWORD xxiii
INTRODUCTION xxv
PART I: INTRODUCTION TO JAVA EE DESIGN PATTERNS
CHAPTER 1: A BRIEF OVERVIEW OF DESIGN PATTERNS 3
What Is a Design Pattern? 4
How Patterns Were Discovered and Why We Need Them 5
Patterns in the Real World 5
Design Pattern Basics 6
Enterprise Patterns 7
Java to Enterprise Java 7
The Emergence of Enterprise Java Patterns 8
Design Patterns Versus Enterprise Patterns 8
Plain Old Design Patterns Meet Java EE 9
When Patterns Become Anti-Patterns 10
Summary 10
Notes 10
CHAPTER 2: THE BASICS OF JAVA EE 13
Multitier Architecture 14
The Client Tier 15
The Middle Tier 16
Web Layer 16
Business Layer 16
The EIS Tier 18
Java EE Servers 18
The Java EE Web Profile 18
Core Principles of Java EE 19
Convention over Configuration 19
Context and Dependency Injection 20
Interceptors 21
Summary 22
Exercises 22
PART II: IMPLEMENTING DESIGN PATTERNS IN JAVA EE
CHAPTER 3: FAÇADE PATTERN 25
What Is a Façade? 26
Façade Class Diagram 27
Implementing the Façade Pattern in Plain Code 27
Implementing the Façade Pattern in Java EE 29
Façade with Stateless Beans 29
Façade with Stateful Bean 31
Where and When to Use the Façade Pattern 31
Summary 31
Exercises 32
Notes 32
CHAPTER 4: SINGLETON PATTERN 33
What Is a Singleton? 34
Singleton Class Diagram 34
Implementing the Singleton Pattern in Plain Code 35
Implementing the Singleton Pattern in Java EE 38
Singleton Beans 39
Using Singletons at Startup 39
Determining Startup Order 40
Managing Concurrency 42
Where and When to Use the Singleton Pattern 45
Summary 46
Exercises 46
Notes 47
CHAPTER 5: DEPENDENCY INJECTION AND CDI 49
What Is Dependency Injection? 50
Implementing DI in Plain Code 50
Implementing DI in Java EE 53
The @Named Annotation 54
Context and Dependency Injection (CDI) 55
CDI Versus EJB 56
CDI Beans 56
The @Inject Annotation 57
Contexts and Scope 57
Naming and EL 58
CDI Beans for Backing JSF 58
Qualifi ers 59
Alternatives 59
Stereotypes 60
Other Patterns via CDI 60
Summary 61
Exercises 61
Notes 62
CHAPTER 6: FACTORY PATTERN 63
What Is a Factory? 64
Factory Method 64
Implementing the Factory Method in Plain Code 66
Abstract Factory 68
Implementing the Abstract Factory in Plain Code 69
Implementing the Factory Pattern in Java EE 70
Harness the Power of CDI 76
Where and When to Use the Factory Patterns 80
Summary 80
Exercises 81
Notes 81
CHAPTER 7: DECORATOR PATTERN 83
What Is a Decorator? 84
Decorator Class Diagram 85
Implementing the Decorator Pattern in Plain Code 86
Implementing the Decorator Pattern in Java EE 89
Decorators Without XML Confi guration 94
Where and When to Use the Decorator Pattern 94
Summary 95
Exercises 96
Notes 96
CHAPTER 8: ASPECT-ORIENTED PROGRAMMING (INTERCEPTORS) 97
What Is Aspect-Oriented Programming? 98
Implementing AOP in Plain Code 100
Aspects in Java EE, Interceptors 102
Interceptor Life Cycle 105
Default-Level Interceptors 106
Interceptor Order 107
CDI Interceptors 109
Where and When to Use Interceptors 111
Summary 112
Notes 112
CHAPTER 9: ASYNCHRONOUS 113
What Is Asynchronous Programming? 114
Asynchronous Pattern 114
Implementing Asynchronous Pattern in Plain Code 116
Asynchronous Programming in Java EE 118
Asynchronous Beans 118
Asynchronous Servlets 120
Where and When to Use Asynchronous Programming 124
Summary 125
Exercises 125
Notes 126
CHAPTER 10: TIMER SERVICE 127
What Is the Timer Service? 127
Implementing a Timer in Java EE 130
Automatic Timers 130
Programmatic Timers 131
Timer Expression 134
Transactions 136
Summary 137
Exercises 137
Notes 138
CHAPTER 11: OBSERVER PATTERN 139
What Is an Observer? 139
Description 140
Observer Class Diagram 141
Implementing the Observer Pattern in Plain Code 142
Implementing the Observer Pattern in Java EE 144
Where and When to Use the Observer Pattern 149
Summary 150
Exercises 151
Notes 151
CHAPTER 12: DATA ACCESS PATTERN 153
What Is a Data Access Pattern? 154
Data Access Class Diagram 154
Overview of the Data Access Pattern 155
Data Transfer Object Pattern 155
Java Persistence Architecture API and Object Relational Mapping 156
Implementing the Data Access Pattern in Java EE 157
Type-Safe DAO Implementation 162
Where and When to Use the Data Access Pattern 163
Summary 163
Exercises 163
Notes 163
CHAPTER 13: RESTFUL WEB SERVICES 165
What Is REST? 166
The Six Constraints of REST 167
Client-Server 167
Uniform Interface 167
Stateless 168
Cacheable 168
Layered System 168
Code on Demand 168
Richardson Maturity Model of REST API 168
Level 0: The Swamp of POX (Plain Old XML) 169
Level 1: Resources 169
Level 2: HTTP Verbs 169
Level 3: Hypermedia Controls 169
Designing a RESTful API 169
Resource Naming 170
Nouns Not Verbs 170
Self-Descriptive 170
Plural Not Singular 171
HTTP Methods 171
Get 171
Post 171
Put 172
Delete 172
Rest in Action 172
The users noun 172
The topics noun and the posts noun 173
Implementing REST in Java EE 175
HATEOAS 178
Where and When to Use REST 180
Summary 181
Exercises 181
Notes 182
CHAPTER 14: MODEL VIEW CONTROLLER PATTERN 183
What Is the MVC Design Pattern? 184
MVC Types 185
Implementing the MVC Pattern in Plain Code 186
Implementing the MVC Pattern in Java EE 190
The FacesServlet 190
MVC Using the FacesServlet 190
Where and When to Use the MVC Pattern 193
Summary 193
Exercises 193
Note 193
CHAPTER 15: OTHER PATTERNS IN JAVA EE 195
What Are WebSockets? 195
What Is Message-Orientated Middleware 198
What Is the Microservice Architecture? 199
Monolithic Architecture 199
Scalability 200
Decomposing into Services 201
Microservice Benefi ts 202
Nothing in Life Is Free 203
Conclusions 204
Finally, Some Anti-Patterns 204
Uber Class 204
Lasagna Architecture 204
Mr. Colombus 205
Friends with Benefi ts 205
Bleeding Edge 205
Utilityman 206
Notes 206
PART III: SUMMARY
CHAPTER 16: DESIGN PATTERNS: THE GOOD,THE BAD, AND THE UGLY 209
The Good: Patterns for Success 209
The Bad: Over and Misuse of Patterns 211
...and The Ugly 212
Summary 214
Notes 214
INDEX 215
