Real-World Java

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