Real-World Software Development: A Project-Driven Guide to Fundamentals in Java

by Raoul-Gabriel Urma, Richard Warburton

Overview

Explore the latest Java-based software development techniques and methodologies through the project-based approach in this practical guide. Unlike books that use abstract examples and lots of theory, Real-World Software Development shows you how to develop several relevant projects while learning best practices along the way.

With this engaging approach, junior developers capable of writing basic Java code will learn about state-of-the-art software development practices for building modern, robust and maintainable Java software. You’ll work with many different software development topics that are often excluded from software develop how-to references.

Featuring real-world examples, this book teaches you techniques and methodologies for functional programming, automated testing, security, architecture, and distributed systems.

Product Details

ISBN-13:	9781491967126
Publisher:	O'Reilly Media, Incorporated
Publication date:	12/02/2019
Sold by:	Barnes & Noble
Format:	eBook
Pages:	202
File size:	3 MB

About the Author

Raoul-Gabriel Urma is a PhD student in Computer Science at the University of Cambridge. His research centers on programming languages and software engineering. He is an author of the upcoming book Java 8 in Action: Lambdas, Streams, and functional-style programming published by Manning.

Richard Warburton is an empirical technologist and solver of deep-dive technical problems. Recently he has worked on data analytics for high performance computing and authored Java 8 Lambdas for O'Reilly. He is a leader in the London Java Community and organized the Adopt-a-JSR programs for Lambdas and Date and Time in Java 8. Richard also frequently speaks at conferences, and has presented at JavaOne, DevoxxUK, Geecon, Jfokus and JAX London. He obtained a PhD in Computer Science from The University of Warwick, where his research focused on compiler theory.

Table of Contents

Preface ix

1 Starting the Journey 1

Themes 1

Java Features 1

Software Design and Architecture 2

SOLID 2

Testing 2

Chapter Summary 3

Iterating on You 4

2 The Bank Statements Analyzer 5

The Challenge 5

The Goal 5

Bank Statements Analyzer Requirements 6

KISS Principle 6

Final Variables 8

Code Maintainability and Anti-Patterns 9

God Class 9

Code Duplication 10

Single Responsibility Principle 10

Cohesion 14

Class-Level Cohesion 17

Method-Level Cohesion 20

Coupling 21

Testing 23

Automated Testing 23

Using JUnit 24

Code Coverage 27

Takeaways 28

Iterating on You 28

Completing the Challenge 29

3 Extending the Bank Statements Analyzer 31

The Challenge 31

The Goal 31

Extended Bank Statements Analyzer Requirements 32

Open/Closed Principle 32

Creating an Instance of a Functional Interface 35

Lambda Expressions 36

Interfaces Gotchas 36

God Interface 37

Too Granular 38

Explicit Versus Implicit API 38

Domain Class or Primitive Value? 40

Multiple Exporters 41

Introducing a Domain Object 41

Denning and Implementing the Appropriate Interface 43

Exception Handling 44

Why Use Exceptions? 45

Patterns and Anti-Patterns with Exceptions 46

Guidelines for Using Exceptions 51

Alternatives to Exceptions 52

Using a Build Tool 54

Why Use a Build Tool? 54

Using Maven 55

Using Gradle 58

Takeaways 60

Iterating on You 61

Completing the Challenge 61

4 The Document Management System 63

The Challenge 63

The Goal 63

Document Management System Requirements 64

Fleshing Out the Design 64

Importers 65

The Document Class 66

Attributes and Hierarchical Documents 68

Implementing and Registering Importers 69

The Liskov Substitution Principle (LSP) 71

Alternative Approaches 73

Making Importer a Class 73

Scoping and Encapsulation Choices 73

Extending and Reusing Code 74

Test Hygiene 79

Test Naming 79

Behavior Not Implementation 81

Don't Repeat Yourself 83

Good Diagnostics 84

Testing Error Cases 86

Constants 87

Takeaways 88

Iterating on You 88

Completing the Challenge 88

5 The Business Rules Engine 89

The Challenge 89

The Goal 89

Business Rules Engine Requirements 90

Test Driven Development 91

Why Use TDD? 92

The TDD Cycle 92

Mocking 95

Adding Conditions 96

Modeling State 96

Local Variable Type Inference 99

Switch Expressions 101

Interface Segregation Principle 103

Designing a Fluent API 106

What Is a Fluent API? 106

Modeling the Domain 107

Builder Pattern 108

Takeaways 111

Iterating on You 112

Completing the Challenge 112

6 Twootr 113

The Challenge 113

The Goal 113

Twootr Requirements 114

Design Overview 115

Pull-Based 116

Push-Based 116

From Events to Design 117

Communication 117

GUI 118

Persistence 119

The Hexagonal Architecture 119

Where to Begin 120

Passwords and Security 125

Followers and Twoots 127

Modeling Errors 128

Twooting 130

Creating Mocks 130

Verifying with Mocks 132

Mocking Libraries 132

SenderEndPoint 133

Positions 135

The equals and hashcode Methods 138

The Contract Between equals and hashCode 139

Takeaways 141

Iterating on You 141

Completing the Challenge 141

7 Extending Twootr 143

The Challenge 143

The Goal 143

Recap 144

Persistence and the Repository Pattern 144

Designing the Repositories 145

Query Objects 147

Functional Programming 151

Lambda Expressions 152

Method References 153

Execute Around 155

Streams 156

Optional 160

User Interface 163

Dependency Inversion and Dependency Injection 164

Packages and Build Systems 167

Limitations and Simplifications 168

Takeaways 169

Iterating on You 169

Completing the Challenge 170

8 Conclusion 171

Project-Based Structure 171

Iterating on You 171

Deliberate Practice 172

Next Steps and Additional Resources 173

Index 175