Real-World Java
Description
A concise handbook for the most common tools used in modern Java development
Good Java developers learn Java syntax, how to create loops and switches, and can work out a lambda filter stream. But great Java developers need to understand the vast ecosystem of tools and frameworks for collaboration, testing, building, and more.
In Real-World Java®: Helping You Navigate the Java Ecosystem, a team of veteran Java developers delivers a concise and authoritative discussion of the most common frameworks, tools, and techniques used in enterprise Java development shops. The authors provide just enough background and examples to allow you to dive right into the expert guidance on annotations, logging frameworks, observability, performance tuning, testing tools, and collaboration, that real-life commercial Java development typically relies on.
You'll expand your Java development toolkit with frameworks and utilities like Spring, Git, Prometheus, and Project Lombok. You'll also discover links to tested, downloadable code examples that demonstrate the skills discussed in the book.
Real-World Java® is the perfect resource for everyone already somewhat comfortable with the language but who wants to familiarize themselves with the tools and frameworks used in contemporary Java software development.
More details
Other editions
Additional editions
Persons
VICTOR GRAZI is an Oracle Java Champion and a veteran Java engineer in the USA, and has built serious Java applications at some of the world's leading banks. He is a Pluralsight author, has served as infoQ Java lead editor, and serves on the Java community process executive committee. Victor is a frequent presenter at technical conferences and hosts the "Java Concurrent Animated" and "Bytecode Explorer" open-source projects.
JEANNE BOYARSKY is an Oracle Java Champion and has worked as a Java developer for a major bank for more than 20 years. She is a senior moderator at CodeRanch, and trains and mentors students of all levels, including the programming department of a FIRST robotics team.
Content
Introduction xxix
Chapter 1: How We Got Here: History of Java in a Nutshell 1
Introduction 1
Understanding the Stewardship of Java 2
Differentiating Key Java Versions 4
Coding Generics in Java 5 4
Coding with Functional Programming from Java 8 4
Coding Modules from Java 11 5
Coding Text Blocks and Records from Java 17 6
Learning About Virtual Threads from Java 21 7
Working with Deprecation and Retirement 7
Identifying Renames 8
Changing to Jakarta EE 8
Renaming Certifications 8
Understanding the Principles of Change 8
Further References 9
Summary 9
Chapter 2: Getting to Know Your Ide: the Secret to Success 11
Understanding IDE History 12
Starting a New Project 13
Creating a Project from Scratch 13
Creating a Project from Existing Sources 14
Creating a Project from Version Control 15
Adding a Project to Version Control 15
Adding a Module to an Existing Project 16
Creating a Run Configuration 16
Getting to Know Your Keyboard Shortcuts 18
Navigating Your Codebase 19
Copying and Pasting Shortcuts 20
Reordering Code 20
Using Other Helpful Shortcuts 21
Debugging Your Code 22
Debugging a Program 22
Speeding Up Debugger Performance 24
Remote Debugging 25
Debugging with Hot Swap 26
Refactoring Your Code 26
Avoiding Duplicate Code 26
Renaming Members 31
Inlining 31
Changing Signatures: Adding and Removing Parameters 32
Exploiting the Editor 32
Automated Reformatting of Code 32
Organizing Imports 32
Reformatting Code 32
Unwrapping 33
Comparing Code 34
Using Column Mode 34
Extending the IDE 35
Peeking at Eclipse 36
Peeking at VS Code 37
Comparing IDEs 39
Further References 40
Summary 40
Chapter 3: Collaborating Across the Enterprise with Git, Jira, and Confluence 41
Collaborating with Git 42
Introducing Git Basics 42
Learning Key Concepts 42
Differentiating Commits 43
Displaying Git Status 43
Branching 43
Tagging 43
Merging 44
Reading Git Logs 44
Staging Your Changes 44
Installing Git 45
Understanding Git Workflow by Example 45
Fetching, Merging, and Pulling 51
Playing with Branches 53
Resolving Merge Conflicts 54
Using Pull/Merge Requests 55
Using the Git Log 56
Rebasing 57
Cherry-Picking 60
Reverting and Resetting 60
Optimizing with IDE Support 61
Looking at the Commit Window 63
Using the Diff-Viewer Window 64
Creating README Files with Markdown Language 69
Using Gitflow for Collaboration 70
Using Jira for Enterprise Process Collaboration 72
Getting Started with Jira 72
Creating a Project 73
Creating an Issue 74
Linking to an Epic 75
Working with Boards 76
Creating a Sprint 76
Adding Users 78
Adding Columns 78
Using Filters 80
Seeing My Issues 80
Querying with JQL 80
Making Bulk Changes 82
Connecting to Git 83
Working with Confluence, the Enterprise Knowledge Management System 83
Further References 86
Summary 86
Chapter 4: Automating Your Ci/cd Builds with Maven, Gradle, and Jenkins 87
Building with Maven 88
Building a Basic Maven Project 89
Understanding the Maven Repository and Dependencies 90
Differentiating Life-Cycle Phases 92
Exploring the POM 93
Working with Properties 93
Specifying Project Information 93
Understanding Version Numbers 94
Using Common Plugins 94
Configuring a Plugin 94
Recognizing Common Plugins 97
Working with a Parent POM 98
Creating Your Own Parent POM 98
Inheriting from the Parent 98
Working with a Multimodule Project 100
Using Other Maven Features 102
Setting System Properties 102
Using a Bill of Materials 102
Releasing Your Project 103
Getting to Know Maven in the IDE 103
Using IntelliJ 103
Using Eclipse 104
Using VS Code 104
Configuring Maven Settings for the Enterprise 106
Building with Gradle 106
Building a Basic Gradle Project 107
Understanding the Gradle Local Repository and Dependencies 109
Specifying Variables 110
Using the Java Plugin 110
Getting to Know Gradle in the IDE 111
Finding a Dependency 112
Integrating with Jenkins 114
Installing Jenkins 114
Learning Jenkins Terminology 116
Creating Jobs 116
Creating a Simple Freestyle Job 117
Creating a Maven Freestyle Job 119
Creating a Gradle Freestyle Job 122
Creating a Maven Pipeline 122
Creating a Gradle Pipeline 124
Learning About Common Plugins 125
Understanding Other Jenkins Capabilities 126
Organizing Jobs 126
Notifying Users 126
Reading Changes 126
Scanning with Sonar 127
Explaining CI/CD Practices 127
Further References 128
Summary 128
Chapter 5: Capturing Application State with Logging Frameworks 129
Needing to Move Beyond Print 130
Using Java Util Logging 130
Comparing Logging Levels 131
Formatting Values 132
Passing Basic Configuration 133
Setting Logging Destinations 134
Logging Lazily 135
Inheriting Loggers 136
Using Log4j 138
Comparing Logging Levels 139
Formatting Values 140
Passing Basic Configuration 141
Comparing Configuration File Formats 142
Setting Logging Destinations 145
Choosing Logging Output Formats 148
Logging Lazily 148
Using SLF4J 149
Omitting a Logging Framework 149
Specifying SLF4J Simple 150
Comparing Logging Levels 150
Formatting Values 151
Logging Lazily 151
Passing Basic Configuration 152
Using SLF4J with Other Logging Frameworks 152
Using Logback 155
Comparing Logging Levels 156
Passing Basic Configuration 156
Setting Logging Destinations 157
Choosing Logging Output Formats 158
Learning More About Logging 159
Deciding on Coding Standards 159
Designing for Performance 159
Choosing a Language for the Logs 159
Preventing Log Tampering 159
Aggregating and Forwarding Logs 160
Comparing Logging Frameworks 160
Further References 161
Summary 161
Chapter 6: Getting to Know the Spring Framework 163
Configuring Spring 164
Using XML Configuration Files 165
Using Java Configuration Classes 167
Using Component Scanning 169
Customizing Spring Applications with Properties 170
Injecting Properties 170
Configuring Environment-Specific Properties with Spring Profiles 171
Turbocharging Development with Spring Boot 173
Initializing Spring Boot Projects with Spring Initializr 173
Using IntelliJ Initializr Integration 174
Working with Spring MVC 178
Handling Errors in Spring 183
Inspecting Your Application with Actuator 185
Securing Your Application with Spring Security 187
Learning Security Terminology 187
Understanding Spring Security Processing 188
Exploring the Spring Projects 192
Further References 193
Summary 193
Chapter 7: Testing Your Code with Automated Testing Tools 195
Understanding Testing Basics 196
Staging Your Test Directory 196
Configuring JUnit in a Maven Build 197
Configuring JUnit in a Gradle Build 200
Using Test-Driven Development to Explore Tests 202
Learning JUnit 205
Looking at Test Flow 205
Skipping a Test 207
Asserting Logic 207
Using Common Assertions 208
Asserting Exceptions 208
Failing Programmatically 209
Verifying Conditions Using Assume Logic 209
Parameterizing Tests 210
Working with Common Testing Libraries 211
Coding Using AssertJ 211
Coding with JUnit Pioneer Features 212
Disabling Until a Date 213
Retrying a Test 213
Working with System Properties 214
Using Cartesian Test 214
Learning About Other Features 214
Mocking Objects 215
Mocking with Mockito 215
Configuring When/Then 218
Verifying Calls 219
Mocking Concrete Classes 220
Mocking Statics 221
Mocking with EasyMock 221
Mocking with Spring MockMvc 222
Measuring Test Coverage 225
Calculating Code Coverage 225
Seeing Code Coverage in the IDE 226
Running Coverage in the Build 227
Optimizing Your Testing with IntelliJ 228
Looking at Assert Messages 228
Exploring Test Runs 229
Navigating to the Test 229
Generating Test Boilerplate with TestMe 230
Learning Other Testing Concepts 231
Using Behavior-Driven Development 231
Testing Contracts 231
Understanding the Golden Master Pattern 231
Testing Mutations 232
Deciding Between DRY vs. DAMP 232
Further References 233
Summary 234
Chapter 8: Annotation Driven Code with Project Lombok 235
Preparing Your Environment for Lombok 236
Installing in IntelliJ 236
Installing in Eclipse 237
Installing in VS Code 237
Including in Maven or Gradle 238
Compiling from javac 239
Implementing Lombok 239
Converting to the Lombok Way 240
Using @Data: the include-all Annotation 240
Autogenerating Your @Getter and @Setter Methods 241
Using @ToString 243
Using @EqualsAndHashCode 244
Generating Constructors with @AllArgsConstructor, @RequiredArgsConstructor, and @NoArgsConstructor Annotations 244
Weaving Loggers into Your Codebase with @Log and More 245
Delomboking Your Codebase 247
Further References 247
Summary 247
Chapter 9: Parallelizing Your Application Using Java Concurrency 249
Understanding Concurrency Basics 250
Dealing with Thread Contention 252
Coding Atomic Operations 254
Using the volatile Keyword 255
Transitioning Thread States 256
New 256
Runnable 256
Blocked 257
Waiting 257
Timed_waiting 257
Terminated 257
Summarizing Thread States 257
Synchronizing 257
Exploring Heap, Stack, and Metaspace 259
Introducing Concurrent Collections 259
Using Built-In Concurrency Support in Java Streams 260
Using Concurrency Components to Reduce Complexity 261
Locking with ReentrantLock 261
Controlling Thread Access with Phaser 262
Using Runnable, Callable, and Future 262
Coordinating with ExecutorService 263
Using Fixed-Count Thread Pools 263
Scheduling with ExecutorService 264
Building Reactive Code with CompletableFuture 265
Functional Interfaces Used by CompletableFuture 265
CompletionStage 268
Putting It All Together with CompletableFuture 269
Introducing Virtual Threads 271
Interthread Communication 276
Learning Concurrency Support in the Spring Framework 278
Using @Async/@EnableAsync 278
Scheduling with @Scheduled/@EnableScheduling 280
Launching Threads with ThreadPoolTaskExecutor 280
Understanding @Transactional 281
Further References 281
Summary 281
Chapter 10: Pattern Matching with Regular Expressions 283
Introducing Regular Expressions 284
Learning Basic Regular Expression Syntax 285
Specifying Common Quantifiers 286
Matching Basic Boundaries 287
Working with Common Character Classes 288
Choosing Options 290
Escaping Characters 290
Using Regular Expressions with Java APIs 291
Calling String Methods 291
Finding Matches 291
Replacing Values 292
Splitting 293
Working with Patterns 294
Finding Matches 295
Replacing Values 296
Splitting as a Stream 298
Controlling Behavior with Flags 298
Exploring Advanced Regular Expression Syntax 300
Looking at Neighboring Text 300
Differentiating Quantifiers 301
Identifying Common Mistakes 304
Coding with Regular Expressions 304
Using with Frameworks and Tools 306
Coding Regular Expressions for Apache Commons Validator 306
Coding Regular Expressions for JUnit 306
Coding Regular Expressions for Log4j 307
Coding Regular Expressions for Bean Validation 307
Coding Regular Expressions for Spring 308
Further References 308
Summary 309
Chapter 11: Coding the Aspect-oriented Way 311
Understanding the Need for Aspects 311
Creating Our First Example 312
Exploring the Pointcut Expression Language 315
* Wildcards 315
.. Wildcards 316
Using @AfterReturning 316
Using @AfterThrowing 317
Using @After 317
Using @Around 317
Using @Pointcut 319
Combining Pointcuts 320
Annotation-Based Pointcuts 321
Further References 323
Summary 323
Chapter 12: Monitoring Your Applications: Observability in the Java Ecosystem 325
Introducing Observability 326
Getting Started with Prometheus 326
Starting the Test Application 326
Installing the Exporter 327
Installing Prometheus 327
Configuring a Scrape 328
Introducing PromQL: The Prometheus Query Language 330
Using Prometheus HTTP APIs 336
Micrometer and Actuator 336
Dependencies for Micrometer and Actuator 337
Creating Custom Metrics 337
Counting Results with Micrometer Counter 337
Capturing Fluctuating Values 338
Bucketing Values with Histograms and Summaries 339
Adding Alert Manager 341
Dashboarding with Grafana 344
Logging and Tracing 347
Introducing Logging 347
Key Concepts in Tracing 349
Tooling 349
Implementing Tracing in Spring Boot Applications 349
Further References 349
Prometheus 349
Other Tools 350
Summary 350
Chapter 13: Performance Tuning Your Services 351
Learning the Concepts and Terminology 352
Benchmarking 352
Benchmarking with Built-In Java APIs 353
Microbenchmarking 354
Tuning JVM Settings 357
Configuring Memory Settings 357
Collecting the Garbage 358
Setting Sizes for Garbage Collection 359
Using Serial Garbage Collection 359
Using Parallel Garbage Collection 359
Using G1GC 360
Testing with JMeter 360
Creating a Test Plan 360
Running the Load Test 363
Analyzing the Results 364
Using JDK Tools 365
Using Java Flight Recorder 366
Visualizing in Java Mission Control 368
Monitoring with JConsole 369
Using VisualVM 370
Reporting with JStat 371
Optimizing Your Application 372
Exploring a Case Study 372
Using SonarQube 374
Considering Performance 375
Further References 375
Summary 376
Chapter 14: Getting to Know More of the Ecosystem 377
Writing Javadoc 378
Comparing JVM Languages 379
Sampling Kotlin 379
Sampling Groovy 380
Sampling Scala 381
Exploring Jakarta EE 381
Comparing Database Types 382
Understanding Relational Databases 382
Understanding NoSQL Databases 384
Learning About Integrations 384
Deploying Java 384
Differentiating Web and Application Servers 385
Using Containers 385
Launching to the Cloud 386
Building REST APIs 387
Creating Web Services 388
Documenting APIs 389
Picking a Virtual Machine 390
Exploring Libraries 390
Securing Your Applications 391
Exploring the OWASP Top 10 391
Comparing Types of Security Tools 393
Staying Informed About Changes 393
Further References 393
Summary 394
Appendix: Reading and Writing Xml, Json, and Yaml 395
Working with XML 396
Learning the XML Format 396
Reading XML with Jackson 397
Writing XML with Jackson 399
Reading and Writing XML with DOM 401
Reading XML with SAX 402
Comparing XML Libraries 403
Working with JSON 404
Learning the JSON Format 404
Reading JSON with Jackson 405
Writing JSON with Jackson 406
Reading and Writing JSON with Gson 407
Comparing JSON Libraries 408
Working with YAML 408
Learning the YAML Format 408
Reading YAML with Jackson 409
Writing YAML with Jackson 410
Reading and Writing with SnakeYAML 410
Comparing YAML Libraries 412
Further References 412
Summary 413
Index 415
1
How We Got Here: History of Java in a Nutshell
WHAT'S IN THIS CHAPTER?
- Understanding the Stewardship of Java
- Differentiating Key Java Versions
- Working with Deprecation and Retirement
- Identifying Renames
- Understanding the Principles of Change
INTRODUCTION
You've learned Java, and you're ready to start using it at work. Or you are already using it in work, but you've discovered the daunting ecosystem that they never taught you in school. This book is for those who have already learned how to code in Java and are looking for the next step. Whether you are a student, career changer, or professional programmer switching languages, this is your opportunity to learn about the Java ecosystem.
This book is not intended to be a comprehensive guide to the Java ecosystem; that would require many thousand-page tomes. If you are just learning Java, we recommend Head First Java, 3rd Edition (O'Reilly Media, 2022) or Java For Dummies (For Dummies, 2025). Then come back to this book. The goal of this book is to expose the reader to some of the most common frameworks, tools, and techniques used in enterprise Java development shops, with enough background and examples to dive right in.
In this chapter, we will cover some information about Java in general before getting into specialized topics in the later chapters. While chapters can be read out of order, we recommend reading Chapters 1-4 before skipping around.
CODE DOWNLOADS FOR THIS CHAPTER
The source code for this chapter is available on the book page at www.wiley.com. Click the Downloads link. The code can also be found at https://github.com/realworldjava/Ch01-History. See the README.md file in that repository for details.
UNDERSTANDING THE STEWARDSHIP OF JAVA
Java was created by James Gosling at Sun Microsystems and released to the world in 1995.
As legend has it, Java started life as "Oak," a new language for building embedded software in smart devices. The idea was novel: instead of writing software for each embedded operating system, design a "write once, run anywhere," compiled, object-oriented language that produces bytecode, and design a bytecode interpreter for each platform that could execute it.
While they were at it, they would include built-in frameworks that were, in other languages, snap-on additions, such as concurrency or UI designers. Then cap it off with memory management in the form of garbage collection and optimize it using just-in-time (JIT) compiling, and voilà, they had everything needed for an embedded language platform.
But alas, it was soon discovered that there was already an "Oak" platform brewing. A long night in a coffee shop over some hot Java brew, and the rest is history.
Many years later, in 2009, Oracle acquired Sun, and ownership of Java transferred to Oracle. To this day, Oracle remains the steward, or caretaker, of Java.
The Java community's commitment to ensuring that Java is backward compatible and its robust series of thousands of Technology Compatibility Kit (TCK) tests that must pass for every feature provide the stability and dependability that have thrust Java into its place as one of the most successful programming languages in history.
Oracle recognizes its stewardship as a critical responsibility, given the sheer number of people and companies heavily using Java. The JCP (Java Community Process) has an Executive Committee (basically Java's board of directors) with many organizations as members to ensure the community is represented. Some past/future members are competitors with their own JDKs (Java Development Kits), for example, Amazon, Azul, and Microsoft. Others are complementary, notably Integrated Development Environment (IDE) providers like Eclipse and JetBrains. Others are simply strong proponents of Java like BellSoft and Fujitsu. Finally, there are community members like SouJava (Brazilian Java User Group) and Ken Fogel (individual member).
One of the changes introduced under Oracle's stewardship was a more frequent and predictable release schedule. Notice in Figure 1.1 that releases have varied in both frequency and month of release. In one case, Java users had to wait more than five years for a new version.
FIGURE 1.1: Java releases
With the new release cadence, a new version of Java comes out every six months. You may be thinking that many companies don't want to upgrade every six months, and you'd be right! There are also less frequent releases called Long-Term Support (LTS) releases. When the new release cycle started, LTS releases were every three years. They are now every two years.
Table 1.1 shows releases from the start of the new release cadence to the publishing of this book. As you can see, there are now regular, predictable releases. This book uses Java 21, which was the latest LTS at the time of printing.
Figure 1.2 shows the LTS release schedule. You can predict LTS dates into the future now that there is a pattern. This helps companies plan.
Many companies run their Java programs remotely, such as through a website. Until 2020, this was often done through Spring or Java EE (Enterprise Edition.) See Chapter 6, "Getting to Know the Spring Framework," and Chapter 14, "Getting to Know More of the Ecosystem," for more details. In 2020, Oracle handed over stewardship of Java EE to an open-source foundation. Since "Java" is a trademark, the Java EE framework was renamed to "Jakarta EE" at that point.
TABLE 1.1: Java Releases
YEAR MARCH RELEASE SEPTEMBER RELEASE 2017 n/a (cadence started in September) Java 9 2018 Java 10 Java 11 (LTS) 2019 Java 12 Java 13 2020 Java 14 Java 15 2021 Java 16 Java 17 (LTS) 2022 Java 18 Java 19 2023 Java 20 Java 21 (LTS) 2024 Java 22 Java 23FIGURE 1.2: LTS release schedule, with future predictions
DIFFERENTIATING KEY JAVA VERSIONS
The Java language has evolved quite a bit over time. By looking at key features added over time, you can get a feel for this evolution along with an expectation that the language will continue to improve. Additionally, you will know what to expect if your work project is not on the latest version.
Note that this section is not even close to a full list of features. We picked the most significant feature of each version covered.
You might be wondering why we aren't including type inference with the var keyword in this section. While both of this book's authors use var in some cases in our work code, we felt it would be clearer in this book to specify what the types are and ensure all imports are represented.
Coding Generics in Java 5
Before Java 5, the compiler had no way of knowing what you intended to put in a list. Java 5 introduced generics, which allow you to specify the type, in the case of the following example, a String:
1: import java.util.ArrayList; 2: import java.util.List; 3: 4: public class Java5Generics { 5: 6: private static List<String> createList() { 7: List<String> buildingNames = new ArrayList<String>(); 8: buildingNames.add("Firehouse"); 9: return buildingNames; 10: } 11: 12: public static void main(String[] args) { 13: List<String> buildingNames = createList(); 14: 15: System.out.println(buildingNames); // [Firehouse] 16: } 17: } Now that we've informed the compiler about our intent, it is our assistant. The compiler will produce an error if we attempt to add an Integer or LocalDate or anything else to buildingNames.
You might be wondering why the line 7 doesn't say new ArrayList<>() and instead uses a longer version. The diamond operator (<>) was added in Java 7, and this example is for Java 5. Even this shows the evolution of the language, though!
Coding with Functional Programming from Java 8
Functional programming is a way of writing code more declaratively. You specify what you want to do rather than dealing with the state of objects. You focus more on expressions than loops.
Java 8 introduced lambdas and method references to facilitate writing code with deferred execution, also known as "code that runs later." Both let you easily pass executable code to a method. In the following code,...
