[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":84,"_71":85,"_35":86},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":52,"_63":64,"_65":66,"_67":68,"_69":70},"id",9,"title","Null Handling Strategies","slug","clean-code-part-8-null-handling","excerpt","Eliminate null-related bugs with Null Object pattern, Optional proper usage, defensive coding strategies, and static analysis tools for null safety.","# Advanced Clean Code Patterns Part 8: Null Handling Patterns\n\nNull is the \"billion dollar mistake\" according to its inventor, Tony Hoare. This article covers strategies to eliminate null-related bugs: Null Object pattern, Optional, defensive coding, and static analysis tools.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Patterns Covered | Null Object, Optional, Defensive Coding |\n| Primary Benefit | Eliminate NullPointerException |\n| Java Version | 8+ (Optional), all (Null Object) |\n| Tools | NullAway, Checker Framework, SpotBugs |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Null Object Pattern** for default behavior\n- **Optional** proper usage and anti-patterns\n- **Defensive coding** with fail-fast validation\n- **Static analysis** for null safety\n- **When null is appropriate** (yes, sometimes)\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Null Object Pattern\n\n```java\n// ✅ Null Object Pattern\npublic interface Discount {\n BigDecimal apply(BigDecimal price);\n String getCode();\n\n // Null Object - singleton instance\n Discount NONE = new Discount() {\n @Override\n public BigDecimal apply(BigDecimal price) {\n return price; // No discount\n }\n\n @Override\n public String getCode() {\n return \"\";\n }\n };\n}\n\npublic class PercentageDiscount implements Discount {\n private final String code;\n private final BigDecimal percentage;\n\n @Override\n public BigDecimal apply(BigDecimal price) {\n return price.multiply(BigDecimal.ONE.subtract(percentage));\n }\n}\n\n// Usage - no null checks needed!\npublic class OrderService {\n public BigDecimal calculateTotal(Order order) {\n Discount discount = discountRepository\n .findByCode(order.getDiscountCode())\n .orElse(Discount.NONE); // Never null\n\n return discount.apply(order.getSubtotal());\n }\n}\n```\n\n---\n\n### Pattern 2: Optional Proper Usage\n\n```java\n// ✅ Good Optional usage\npublic class UserService {\n\n // Return Optional for \"might not exist\"\n public Optional findById(Long id) {\n return userRepository.findById(id);\n }\n\n // Transform safely\n public Optional getUserEmail(Long id) {\n return findById(id)\n .map(User::getEmail);\n }\n\n // Provide default\n public User getOrCreateGuest(Long id) {\n return findById(id)\n .orElseGet(this::createGuestUser);\n }\n\n // Throw on missing\n public User getRequired(Long id) {\n return findById(id)\n .orElseThrow(() -> new UserNotFoundException(id));\n }\n}\n\n// ❌ Optional anti-patterns\npublic class BadExamples {\n // Don't use as field\n private Optional user; // ❌\n\n // Don't use as parameter\n public void process(Optional name) { } // ❌\n\n // Don't call get() without check\n public String getName(Optional user) {\n return user.get().getName(); // ❌ May throw!\n }\n\n // Don't use for simple null checks\n public void process(User user) {\n Optional.ofNullable(user)\n .ifPresent(this::doProcess); // ❌ Overkill\n }\n}\n\n// ✅ Better alternatives\npublic class GoodExamples {\n private User user; // Just use null or Null Object\n\n public void process(String name) { // Make it required\n Objects.requireNonNull(name);\n }\n\n public String getName(User user) {\n return user != null ? user.getName() : \"Unknown\";\n }\n}\n```\n\n---\n\n### Pattern 3: Defensive Coding\n\n```java\n// ✅ Fail-fast validation\npublic class Order {\n private final Long id;\n private final Customer customer;\n private final List items;\n\n public Order(Long id, Customer customer, List items) {\n this.id = Objects.requireNonNull(id, \"id required\");\n this.customer = Objects.requireNonNull(customer, \"customer required\");\n this.items = List.copyOf(Objects.requireNonNull(items, \"items required\"));\n\n if (items.isEmpty()) {\n throw new IllegalArgumentException(\"Order must have items\");\n }\n }\n}\n\n// ✅ Guard clauses at boundaries\n@PostMapping(\"/orders\")\npublic ResponseEntity createOrder(@RequestBody OrderRequest request) {\n // Validate at API boundary\n if (request == null) {\n return ResponseEntity.badRequest().build();\n }\n if (request.getCustomerId() == null) {\n throw new ValidationException(\"customerId required\");\n }\n\n // After validation, internal code can trust inputs\n return ResponseEntity.ok(orderService.create(request));\n}\n```\n\n---\n\n### Pattern 4: Annotations for Static Analysis\n\n```java\n// ✅ Using JSR-305 annotations with SpotBugs/NullAway\n\npublic class UserService {\n\n @Nullable // May return null\n public User findByEmail(String email) {\n return repository.findByEmail(email);\n }\n\n @NonNull // Never returns null\n public User getById(Long id) {\n return repository.findById(id)\n .orElseThrow(() -> new NotFoundException(id));\n }\n\n // Parameter must not be null\n public void save(@NonNull User user) {\n repository.save(user);\n }\n}\n```\n\n---\n\n### Pattern 5: Java 21+ Null in Pattern Matching\n\n```java\n// ✅ Java 21: Explicit null handling in switch\npublic String processValue(Object value) {\n return switch (value) {\n case null -> \"No value provided\";\n case String s when s.isBlank() -> \"Empty string\";\n case String s -> \"String: \" + s;\n case Integer i -> \"Number: \" + i;\n default -> \"Unknown: \" + value;\n };\n}\n\n// ✅ Combined with sealed types - exhaustive null-safe switch\npublic sealed interface Result permits Success, Failure, Empty {}\npublic record Success(T value) implements Result {}\npublic record Failure(String error) implements Result {}\npublic record Empty() implements Result {}\n\npublic String handleResult(Result result) {\n return switch (result) {\n case null -> \"Null result - programming error!\";\n case Success(var value) -> \"Success: \" + value;\n case Failure(var error) -> \"Failed: \" + error;\n case Empty() -> \"No result\";\n };\n}\n```\n\n---\n\n## ⚠️ When Null is Appropriate\n\n1. **Uninitialized lazy fields** (with proper null checks)\n2. **Absent optional data in domain** (though Optional often better)\n3. **Performance-critical code** (Optional has overhead)\n4. **Framework contracts** (JPA entities, etc.)\n\n---\n\n## 🐛 Debug This: The Phantom Null\n\nA developer reports: \"We added Optional everywhere but still getting NullPointerException. I thought Optional was supposed to fix this!\"\n\n```java\npublic class UserService {\n private final UserRepository userRepository;\n\n public UserDetails getUserDetails(Long userId) {\n Optional user = userRepository.findById(userId);\n\n // \"Safe\" Optional usage - still crashes!\n String email = user.get().getEmail(); // NPE if user empty!\n\n // Another \"safe\" approach - still crashes!\n Address address = user.orElse(null).getAddress(); // NPE!\n\n // Yet another attempt - still crashes!\n Optional phone = user.map(User::getPhone);\n String phoneNumber = phone.get(); // NPE if phone is null!\n\n return new UserDetails(email, address, phoneNumber);\n }\n}\n```\n\n**Why does Optional fail to prevent NPE here? Find all the mistakes!**\n\n---\n\n**✅ Solution:**\n\nThree distinct Optional anti-patterns:\n\n1. **`.get()` without `.isPresent()`** - defeats the purpose of Optional\n2. **`.orElse(null)`** - reintroduces null into the codebase\n3. **`.map()` to Optional** - null values inside Optional cause issues\n\n**Correct approach:**\n\n```java\npublic Optional getUserDetails(Long userId) {\n return userRepository.findById(userId)\n .map(user -> new UserDetails(\n user.getEmail(),\n user.getAddress(), // Address should never be null, or use Optional\n Optional.ofNullable(user.getPhone()).orElse(\"N/A\")\n ));\n}\n\n// Or with explicit handling:\npublic UserDetails getUserDetailsOrThrow(Long userId) {\n User user = userRepository.findById(userId)\n .orElseThrow(() -> new UserNotFoundException(userId));\n\n return new UserDetails(\n user.getEmail(),\n Objects.requireNonNull(user.getAddress(), \"Address required\"),\n Optional.ofNullable(user.getPhone()).orElse(\"N/A\")\n );\n}\n```\n\n**The lesson:** Optional only helps if used correctly. Never call `.get()` without checking, never use `.orElse(null)`, and handle nested nulls explicitly.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Eliminate Null Returns\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Refactor to eliminate null returns.\n\n```java\npublic User findUserByEmail(String email) {\n User user = userRepository.findByEmail(email);\n if (user == null) {\n return null; // Bad!\n }\n return user;\n}\n\npublic String getUserDisplayName(Long userId) {\n User user = findUserById(userId);\n if (user == null) {\n return null; // Bad!\n }\n if (user.getNickname() != null) {\n return user.getNickname();\n }\n return user.getFirstName() + \" \" + user.getLastName();\n}\n```\n\n**✅ Solution:**\n\n```java\npublic Optional findUserByEmail(String email) {\n return userRepository.findByEmail(email); // Repository returns Optional\n}\n\npublic String getUserDisplayName(Long userId) {\n return findUserById(userId)\n .map(user -> Optional.ofNullable(user.getNickname())\n .orElseGet(() -> user.getFirstName() + \" \" + user.getLastName()))\n .orElse(\"Unknown User\");\n}\n```\n\n---\n\n### Exercise 2: Implement Null Object Pattern\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Replace null checks with Null Object.\n\n```java\npublic interface Logger {\n void log(String message);\n}\n\npublic class FileLogger implements Logger {\n public void log(String message) {\n // Write to file\n }\n}\n\npublic class OrderService {\n private Logger logger; // Can be null!\n\n public void processOrder(Order order) {\n if (logger != null) {\n logger.log(\"Processing order: \" + order.getId());\n }\n\n // ... process ...\n\n if (logger != null) {\n logger.log(\"Order processed: \" + order.getId());\n }\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic interface Logger {\n void log(String message);\n\n // Null Object - logs nothing\n Logger NULL = message -> { };\n}\n\npublic class OrderService {\n private final Logger logger;\n\n public OrderService(Logger logger) {\n this.logger = logger != null ? logger : Logger.NULL;\n }\n\n public void processOrder(Order order) {\n logger.log(\"Processing order: \" + order.getId()); // No null check!\n // ... process ...\n logger.log(\"Order processed: \" + order.getId());\n }\n}\n```\n\n---\n\n### Exercise 3: Defensive Coding\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Add fail-fast null validation.\n\n```java\npublic class PaymentService {\n public Receipt processPayment(Customer customer, Order order, PaymentMethod method) {\n // No validation - NPE waiting to happen\n BigDecimal amount = order.getTotal();\n String customerId = customer.getId();\n String paymentType = method.getType();\n\n // ... process payment ...\n\n return new Receipt(customerId, amount, paymentType);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class PaymentService {\n public Receipt processPayment(Customer customer, Order order, PaymentMethod method) {\n // Fail fast - clear error messages\n Objects.requireNonNull(customer, \"Customer cannot be null\");\n Objects.requireNonNull(order, \"Order cannot be null\");\n Objects.requireNonNull(method, \"PaymentMethod cannot be null\");\n Objects.requireNonNull(order.getTotal(), \"Order total cannot be null\");\n\n BigDecimal amount = order.getTotal();\n String customerId = customer.getId();\n String paymentType = method.getType();\n\n // ... process payment ...\n\n return new Receipt(customerId, amount, paymentType);\n }\n}\n```\n\n---\n\n### Exercise 4: Optional Chain Refactoring\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Refactor these null checks to Optional chains.\n\n```java\npublic String getCustomerCity(Order order) {\n if (order != null) {\n Customer customer = order.getCustomer();\n if (customer != null) {\n Address address = customer.getAddress();\n if (address != null) {\n return address.getCity();\n }\n }\n }\n return \"Unknown\";\n}\n```\n\n**✅ Solution:**\n\n```java\npublic String getCustomerCity(Order order) {\n return Optional.ofNullable(order)\n .map(Order::getCustomer)\n .map(Customer::getAddress)\n .map(Address::getCity)\n .orElse(\"Unknown\");\n}\n```\n\n---\n\n### Exercise 5: Static Analysis Setup\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Add null-safety annotations and configure static analysis.\n\n```java\n// Current code - no null safety\npublic class UserRepository {\n public User findById(Long id) { ... }\n public List findByRole(String role) { ... }\n public void save(User user) { ... }\n}\n```\n\n**✅ Solution:**\n\n```java\nimport org.springframework.lang.NonNull;\nimport org.springframework.lang.Nullable;\n\npublic interface UserRepository {\n @Nullable\n User findById(@NonNull Long id);\n\n @NonNull\n List findByRole(@NonNull String role); // Never returns null, empty list instead\n\n void save(@NonNull User user);\n}\n\n// Gradle configuration for NullAway\n// build.gradle.kts\nplugins {\n id(\"net.ltgt.errorprone\") version \"3.0.1\"\n}\n\ndependencies {\n errorprone(\"com.uber.nullaway:nullaway:0.10.10\")\n compileOnly(\"org.jetbrains:annotations:24.0.0\")\n}\n\ntasks.withType().configureEach {\n options.errorprone {\n check(\"NullAway\", CheckSeverity.ERROR)\n option(\"NullAway:AnnotatedPackages\", \"com.example\")\n }\n}\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Q1: When would you use Null Object vs Optional?\n\n**A:**\n- **Null Object**: When \"nothing\" has default behavior (NullDiscount applies no discount)\n- **Optional**: When \"nothing\" means absence (no user found)\n- Null Object is about polymorphic behavior, Optional is about presence/absence\n\n### Q2: What are Optional anti-patterns?\n\n**A:**\n- Calling `.get()` without `.isPresent()` check\n- Using `.orElse(null)` - reintroduces null\n- Using Optional as method parameters\n- Using Optional for class fields (serialization issues)\n- Creating Optional just to call `.isPresent()`\n\n### Q3: How do you handle null in legacy code integration?\n\n**A:**\n- Wrap at boundary: `Optional.ofNullable(legacyMethod())`\n- Create adapter classes with null-safe API\n- Add `@Nullable` annotations for documentation\n- Use defensive `Objects.requireNonNull()` at entry points\n\n---\n\n## 📝 Summary\n\n| Pattern | Use When |\n|---------|----------|\n| Null Object | Need default behavior |\n| Optional | Return values that might be absent |\n| requireNonNull | Validate parameters |\n| @Nullable/@NonNull | Static analysis |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Null Object vs Optional decision table | 5 min |\n| Day 3 | Redo Exercise 1 (Eliminate Null Returns) | 15 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Optional anti-patterns) | 10 min |\n| Day 30 | Audit one class in your project for null-safety | 15 min |\n\n---\n\n*Next: [Part 9: Builder & Factory Patterns]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.728925Z","createdAt","2026-06-10T07:19:24.729466Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",8,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder","author",{"_31":55,"_97":57,"_98":99,"_100":101,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5},"category",{"_31":93,"_71":59,"_35":94,"_74":95,"_96":-5},"tags",[77,78,79,80],"series",{"_31":16,"_71":72,"_35":73,"_74":75,"_76":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":90,"_71":91,"_35":92},{"_31":87,"_71":88,"_35":89},{"_31":84,"_71":85,"_35":86},{"_31":81,"_71":82,"_35":83},45,"Optional","optional",47,"Nullpointerexception","nullpointerexception",44,"Null Safety","null-safety",46,"Null Object Pattern","null-object-pattern",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]