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 [...] the include-all Annotation 240

Autogenerating Your [...] and [...] Methods 241

Using [...]...