[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":91,"_72":92,"_35":93},"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":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",16,"title","The Result Pattern","slug","clean-code-part-15-result-pattern","excerpt","Handle expected failures without exceptions using Result types (Success/Failure) with functional composition for explicit error handling.","# Advanced Clean Code Patterns Part 15: Result Pattern\n\nThe Result pattern provides an alternative to exceptions for handling expected failures. Instead of throwing, methods return a Result object that can be either Success or Failure. This article covers implementing Result types, when to use them vs exceptions, and functional composition.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Also Known As | Either, Try, Outcome |\n| Primary Benefit | Explicit error handling, functional composition |\n| Trade-offs | More verbose, different mental model |\n| Best For | Expected failures, validation, parsing |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Result type** implementation in Java\n- **When to use Result** vs exceptions\n- **Functional composition** with map/flatMap\n- **Validation** with error accumulation\n- **Integration** with existing code\n\n---\n\n## Production Story: The Silent Failure Bug\n\nA user import service had a bug that silently skipped invalid users:\n\n```java\n// ❌ Boolean return - no information about what failed\npublic boolean importUser(UserDto dto) {\n try {\n User user = validateAndCreate(dto);\n repository.save(user);\n return true;\n } catch (Exception e) {\n log.warn(\"Failed to import user\", e);\n return false;\n }\n}\n\n// Caller has no idea why it failed\nint success = 0, failed = 0;\nfor (UserDto dto : users) {\n if (importUser(dto)) {\n success++;\n } else {\n failed++; // Why did it fail? We'll never know!\n }\n}\n```\n\n**The fix:** Result pattern with error details:\n\n```java\n// ✅ Result carries success value OR error details\npublic Result importUser(UserDto dto) {\n return validate(dto)\n .flatMap(this::createUser)\n .flatMap(this::saveUser);\n}\n\n// Caller gets full context\nImportReport report = new ImportReport();\nfor (UserDto dto : users) {\n importUser(dto)\n .onSuccess(user -> report.recordSuccess(user))\n .onFailure(error -> report.recordFailure(dto, error));\n}\n```\n\n---\n\n## Mental Model: Exception vs Result\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ EXCEPTIONS VS RESULT PATTERN │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ EXCEPTIONS │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ method() ───→ return value │ │\n│ │ │ │ │\n│ │ └──→ throw Exception (hidden control flow!) │ │\n│ │ │ │\n│ │ Pros: Familiar, separates happy/error paths │ │\n│ │ Cons: Hidden control flow, try-catch boilerplate │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n│ RESULT PATTERN │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ method() ───→ Result │ │\n│ │ │ │ │\n│ │ ├── Success(value) │ │\n│ │ └── Failure(error) │ │\n│ │ │ │\n│ │ Pros: Explicit, composable, no hidden flow │ │\n│ │ Cons: Different mental model, more verbose │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n│ WHEN TO USE WHICH │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ Exceptions: Unexpected failures, programming errors │ │\n│ │ Result: Expected failures, validation, parsing, APIs │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Basic Result Type\n\n```java\n// ✅ Sealed Result type with Success and Failure\n\npublic sealed interface Result permits Success, Failure {\n\n // Factory methods\n static Result success(T value) {\n return new Success<>(value);\n }\n\n static Result failure(E error) {\n return new Failure<>(error);\n }\n\n // Query methods\n boolean isSuccess();\n boolean isFailure();\n\n // Unwrap methods\n T getValue();\n E getError();\n T getOrElse(T defaultValue);\n T getOrElseGet(Supplier supplier);\n T getOrElseThrow(Function exceptionMapper) throws X;\n\n // Transformation methods\n Result map(Function mapper);\n Result flatMap(Function> mapper);\n Result mapError(Function mapper);\n\n // Side effect methods\n Result onSuccess(Consumer action);\n Result onFailure(Consumer action);\n Result peek(Consumer successAction, Consumer failureAction);\n}\n\npublic record Success(T value) implements Result {\n\n @Override\n public boolean isSuccess() { return true; }\n\n @Override\n public boolean isFailure() { return false; }\n\n @Override\n public T getValue() { return value; }\n\n @Override\n public E getError() {\n throw new IllegalStateException(\"No error in Success\");\n }\n\n @Override\n public T getOrElse(T defaultValue) { return value; }\n\n @Override\n public T getOrElseGet(Supplier supplier) { return value; }\n\n @Override\n public T getOrElseThrow(Function mapper) {\n return value;\n }\n\n @Override\n public Result map(Function mapper) {\n return new Success<>(mapper.apply(value));\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return mapper.apply(value);\n }\n\n @Override\n public Result mapError(Function mapper) {\n return new Success<>(value);\n }\n\n @Override\n public Result onSuccess(Consumer action) {\n action.accept(value);\n return this;\n }\n\n @Override\n public Result onFailure(Consumer action) {\n return this;\n }\n\n @Override\n public Result peek(Consumer successAction, Consumer failureAction) {\n successAction.accept(value);\n return this;\n }\n}\n\npublic record Failure(E error) implements Result {\n\n @Override\n public boolean isSuccess() { return false; }\n\n @Override\n public boolean isFailure() { return true; }\n\n @Override\n public T getValue() {\n throw new IllegalStateException(\"No value in Failure: \" + error);\n }\n\n @Override\n public E getError() { return error; }\n\n @Override\n public T getOrElse(T defaultValue) { return defaultValue; }\n\n @Override\n public T getOrElseGet(Supplier supplier) { return supplier.get(); }\n\n @Override\n public T getOrElseThrow(Function mapper) throws X {\n throw mapper.apply(error);\n }\n\n @Override\n @SuppressWarnings(\"unchecked\")\n public Result map(Function mapper) {\n return (Result) this;\n }\n\n @Override\n @SuppressWarnings(\"unchecked\")\n public Result flatMap(Function> mapper) {\n return (Result) this;\n }\n\n @Override\n public Result mapError(Function mapper) {\n return new Failure<>(mapper.apply(error));\n }\n\n @Override\n public Result onSuccess(Consumer action) {\n return this;\n }\n\n @Override\n public Result onFailure(Consumer action) {\n action.accept(error);\n return this;\n }\n\n @Override\n public Result peek(Consumer successAction, Consumer failureAction) {\n failureAction.accept(error);\n return this;\n }\n}\n```\n\n---\n\n### Pattern 2: Using Result in Business Logic\n\n```java\n// ✅ Result in service layer\n\npublic class OrderService {\n\n public Result createOrder(CreateOrderRequest request) {\n return validateRequest(request)\n .flatMap(this::checkInventory)\n .flatMap(this::reserveItems)\n .flatMap(this::createOrderEntity)\n .flatMap(this::saveOrder);\n }\n\n private Result validateRequest(CreateOrderRequest request) {\n if (request.getItems() == null || request.getItems().isEmpty()) {\n return Result.failure(OrderError.emptyCart());\n }\n if (request.getCustomerId() == null) {\n return Result.failure(OrderError.missingCustomer());\n }\n return Result.success(request);\n }\n\n private Result checkInventory(CreateOrderRequest request) {\n for (OrderItemRequest item : request.getItems()) {\n int available = inventoryService.getAvailable(item.getProductId());\n if (available < item.getQuantity()) {\n return Result.failure(OrderError.insufficientInventory(\n item.getProductId(), item.getQuantity(), available));\n }\n }\n return Result.success(request);\n }\n\n private Result reserveItems(CreateOrderRequest request) {\n try {\n ReservedItems reserved = inventoryService.reserve(request.getItems());\n return Result.success(reserved);\n } catch (ReservationException e) {\n return Result.failure(OrderError.reservationFailed(e.getMessage()));\n }\n }\n\n private Result createOrderEntity(ReservedItems reserved) {\n Order order = Order.builder()\n .items(reserved.getItems())\n .total(reserved.calculateTotal())\n .status(OrderStatus.PENDING)\n .build();\n return Result.success(order);\n }\n\n private Result saveOrder(Order order) {\n try {\n return Result.success(orderRepository.save(order));\n } catch (DataAccessException e) {\n return Result.failure(OrderError.saveFailed(e.getMessage()));\n }\n }\n}\n\n// Error type\npublic record OrderError(String code, String message, Map details) {\n\n public static OrderError emptyCart() {\n return new OrderError(\"EMPTY_CART\", \"Cart is empty\", Map.of());\n }\n\n public static OrderError missingCustomer() {\n return new OrderError(\"MISSING_CUSTOMER\", \"Customer ID required\", Map.of());\n }\n\n public static OrderError insufficientInventory(Long productId, int requested, int available) {\n return new OrderError(\"INSUFFICIENT_INVENTORY\",\n String.format(\"Product %d: requested %d, available %d\", productId, requested, available),\n Map.of(\"productId\", productId, \"requested\", requested, \"available\", available));\n }\n\n public static OrderError reservationFailed(String reason) {\n return new OrderError(\"RESERVATION_FAILED\", reason, Map.of());\n }\n\n public static OrderError saveFailed(String reason) {\n return new OrderError(\"SAVE_FAILED\", reason, Map.of());\n }\n}\n```\n\n---\n\n### Pattern 3: Controller Integration\n\n```java\n// ✅ Result in REST controller\n\n@RestController\n@RequestMapping(\"/api/orders\")\npublic class OrderController {\n\n private final OrderService orderService;\n\n @PostMapping\n public ResponseEntity createOrder(@RequestBody CreateOrderRequest request) {\n return orderService.createOrder(request)\n .map(order -> ResponseEntity.status(HttpStatus.CREATED).body(order))\n .getOrElseGet(error -> ResponseEntity\n .status(mapToHttpStatus(error))\n .body(new ErrorResponse(error.code(), error.message(), error.details())));\n }\n\n private HttpStatus mapToHttpStatus(OrderError error) {\n return switch (error.code()) {\n case \"EMPTY_CART\", \"MISSING_CUSTOMER\" -> HttpStatus.BAD_REQUEST;\n case \"INSUFFICIENT_INVENTORY\" -> HttpStatus.CONFLICT;\n case \"RESERVATION_FAILED\", \"SAVE_FAILED\" -> HttpStatus.INTERNAL_SERVER_ERROR;\n default -> HttpStatus.INTERNAL_SERVER_ERROR;\n };\n }\n}\n\n// Alternative: Pattern matching (Java 21+)\n@PostMapping\npublic ResponseEntity createOrder(@RequestBody CreateOrderRequest request) {\n return switch (orderService.createOrder(request)) {\n case Success(var order) -> ResponseEntity.status(HttpStatus.CREATED).body(order);\n case Failure(var error) -> ResponseEntity\n .status(mapToHttpStatus(error))\n .body(new ErrorResponse(error.code(), error.message()));\n };\n}\n```\n\n---\n\n### Pattern 4: Validation with Error Accumulation\n\n```java\n// ✅ Accumulate all validation errors instead of fail-fast\n\npublic class ValidationResult {\n private final T value;\n private final List errors;\n\n private ValidationResult(T value, List errors) {\n this.value = value;\n this.errors = errors;\n }\n\n public static ValidationResult valid(T value) {\n return new ValidationResult<>(value, List.of());\n }\n\n public static ValidationResult invalid(List errors) {\n return new ValidationResult<>(null, List.copyOf(errors));\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public Result> toResult() {\n if (isValid()) {\n return Result.success(value);\n }\n return Result.failure(errors);\n }\n\n public ValidationResult merge(ValidationResult other) {\n List combined = new ArrayList<>(this.errors);\n combined.addAll(other.errors);\n return new ValidationResult<>(this.value, combined);\n }\n}\n\n// Validator interface\n@FunctionalInterface\npublic interface Validator {\n ValidationResult validate(T value);\n\n default Validator and(Validator other) {\n return value -> this.validate(value).merge(other.validate(value));\n }\n}\n\n// Usage - compose validators\npublic class UserValidator {\n\n public static final Validator EMAIL = user -> {\n if (user.getEmail() == null || !user.getEmail().contains(\"@\")) {\n return ValidationResult.invalid(List.of(\n new ValidationError(\"email\", \"Invalid email format\")));\n }\n return ValidationResult.valid(user);\n };\n\n public static final Validator PASSWORD = user -> {\n List errors = new ArrayList<>();\n String pwd = user.getPassword();\n\n if (pwd == null || pwd.length() < 8) {\n errors.add(new ValidationError(\"password\", \"At least 8 characters\"));\n }\n if (pwd != null && !pwd.matches(\".*[A-Z].*\")) {\n errors.add(new ValidationError(\"password\", \"Must contain uppercase\"));\n }\n if (pwd != null && !pwd.matches(\".*[0-9].*\")) {\n errors.add(new ValidationError(\"password\", \"Must contain number\"));\n }\n\n return errors.isEmpty()\n ? ValidationResult.valid(user)\n : ValidationResult.invalid(errors);\n };\n\n public static final Validator AGE = user -> {\n if (user.getAge() != null && user.getAge() < 18) {\n return ValidationResult.invalid(List.of(\n new ValidationError(\"age\", \"Must be 18 or older\")));\n }\n return ValidationResult.valid(user);\n };\n\n // Compose all validators\n public static final Validator ALL = EMAIL.and(PASSWORD).and(AGE);\n}\n\n// Usage\nResult> result = UserValidator.ALL\n .validate(user)\n .toResult();\n\nresult.onFailure(errors -> {\n // All errors collected, not just first\n errors.forEach(e -> log.warn(\"Validation: {} - {}\", e.field(), e.message()));\n});\n```\n\n---\n\n### Pattern 5: Combining Multiple Results\n\n```java\n// ✅ Combining multiple Results\n\npublic class Results {\n\n // Combine two results\n public static Result, E> combine(\n Result first,\n Result second) {\n\n if (first.isFailure()) return Result.failure(first.getError());\n if (second.isFailure()) return Result.failure(second.getError());\n return Result.success(new Pair<>(first.getValue(), second.getValue()));\n }\n\n // Combine list of results\n public static Result, E> sequence(List> results) {\n List values = new ArrayList<>();\n\n for (Result result : results) {\n if (result.isFailure()) {\n return Result.failure(result.getError());\n }\n values.add(result.getValue());\n }\n\n return Result.success(values);\n }\n\n // Combine with error accumulation\n public static Result, List> sequenceAll(List> results) {\n List values = new ArrayList<>();\n List errors = new ArrayList<>();\n\n for (Result result : results) {\n if (result.isSuccess()) {\n values.add(result.getValue());\n } else {\n errors.add(result.getError());\n }\n }\n\n if (errors.isEmpty()) {\n return Result.success(values);\n }\n return Result.failure(errors);\n }\n}\n\n// Usage\nResult userResult = userService.findById(userId);\nResult accountResult = accountService.findByUserId(userId);\n\n// Combine - fail on first error\nResult, ?> combined = Results.combine(userResult, accountResult);\n\n// Process list\nList> results = items.stream()\n .map(this::processItem)\n .toList();\n\nResult, ProcessError> allSuccessful = Results.sequence(results);\nResult, List> withAllErrors = Results.sequenceAll(results);\n```\n\n---\n\n### Pattern 6: Try - Exception to Result Bridge\n\n```java\n// ✅ Bridge between exception-throwing code and Result\n\npublic class Try {\n\n public static Result of(ThrowingSupplier supplier) {\n try {\n return Result.success(supplier.get());\n } catch (Exception e) {\n return Result.failure(e);\n }\n }\n\n public static Result of(\n ThrowingSupplier supplier,\n Function errorMapper) {\n try {\n return Result.success(supplier.get());\n } catch (Exception e) {\n return Result.failure(errorMapper.apply(e));\n }\n }\n\n public static Result run(ThrowingRunnable runnable) {\n try {\n runnable.run();\n return Result.success(null);\n } catch (Exception e) {\n return Result.failure(e);\n }\n }\n}\n\n@FunctionalInterface\npublic interface ThrowingSupplier {\n T get() throws Exception;\n}\n\n@FunctionalInterface\npublic interface ThrowingRunnable {\n void run() throws Exception;\n}\n\n// Usage - wrap exception-throwing code\nResult result = Try.of(() ->\n objectMapper.readValue(json, User.class));\n\nResult mapped = Try.of(\n () -> objectMapper.readValue(json, User.class),\n e -> new ParseError(\"Failed to parse user\", e.getMessage()));\n\n// Chain with exception-throwing methods\nResult config = Try.of(\n () -> Files.readString(Path.of(\"config.json\")),\n e -> ConfigError.readFailed(e))\n .flatMap(json -> Try.of(\n () -> parseConfig(json),\n e -> ConfigError.parseFailed(e)));\n```\n\n---\n\n## When to Use Result vs Exceptions\n\n| Scenario | Use Result | Use Exception |\n|----------|------------|---------------|\n| Validation failures | | |\n| Parsing/conversion | | |\n| Expected business failures | | |\n| Programming errors | | |\n| Unexpected failures | | |\n| Infrastructure failures | | |\n| Cross-boundary errors | | |\n\n**Rule of thumb:**\n- **Result**: When failure is part of normal operation (validation, not found, business rule)\n- **Exception**: When failure is exceptional/unexpected (bugs, system failures)\n\n---\n\n## 🐛 Debug This: The Lost Error\n\nA developer reports: \"Our Result-based validation always shows success even when there are errors!\"\n\n```java\npublic class UserService {\n\n public Result createUser(CreateUserRequest request) {\n Result validated = validate(request);\n\n // BUG: This always succeeds!\n User user = userRepository.save(new User(\n request.getEmail(),\n request.getName()\n ));\n\n return Result.success(user);\n }\n\n private Result validate(CreateUserRequest request) {\n if (request.getEmail() == null || !request.getEmail().contains(\"@\")) {\n return Result.failure(new ValidationError(\"email\", \"Invalid email\"));\n }\n if (request.getName() == null || request.getName().isBlank()) {\n return Result.failure(new ValidationError(\"name\", \"Name required\"));\n }\n return Result.success(request);\n }\n}\n\n// Test:\n// createUser(new CreateUserRequest(null, null))\n// Expected: Failure with validation error\n// Actual: Success - user saved with null email!\n```\n\n**Why does validation appear to pass when it should fail?**\n\n---\n\n**✅ Solution:**\n\nThe bug is that the validation result is **stored but never used**. The code calls `validate()` but then ignores the returned `Result` and proceeds to save the user anyway.\n\n```java\nResult validated = validate(request);\n// validated is NEVER checked or used!\n\n// Code proceeds regardless of validation result\nUser user = userRepository.save(new User(request.getEmail(), request.getName()));\n```\n\n**The fix - chain the validation result:**\n\n```java\npublic Result createUser(CreateUserRequest request) {\n return validate(request)\n .map(validRequest -> new User(\n validRequest.getEmail(),\n validRequest.getName()))\n .map(userRepository::save);\n}\n\n// Or with flatMap if save returns Result\npublic Result createUser(CreateUserRequest request) {\n return validate(request)\n .flatMap(validRequest -> {\n try {\n User user = userRepository.save(new User(\n validRequest.getEmail(),\n validRequest.getName()));\n return Result.success(user);\n } catch (DataAccessException e) {\n return Result.failure(new ValidationError(\"save\", e.getMessage()));\n }\n });\n}\n```\n\n**The lesson:** Result pattern only works when you chain operations properly. Always use `map` or `flatMap` to continue the computation - never ignore the Result!\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Implement Basic Result Type\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Implement a simple Result type with basic operations.\n\n```java\n// Implement SimpleResult with:\n// - static success(T value)\n// - static failure(E error)\n// - isSuccess(), isFailure()\n// - getValue(), getError()\n// - getOrElse(T defaultValue)\n```\n\n**✅ Solution:**\n\n```java\npublic sealed interface SimpleResult permits SimpleSuccess, SimpleFailure {\n\n static SimpleResult success(T value) {\n return new SimpleSuccess<>(value);\n }\n\n static SimpleResult failure(E error) {\n return new SimpleFailure<>(error);\n }\n\n boolean isSuccess();\n boolean isFailure();\n T getValue();\n E getError();\n T getOrElse(T defaultValue);\n}\n\npublic record SimpleSuccess(T value) implements SimpleResult {\n @Override public boolean isSuccess() { return true; }\n @Override public boolean isFailure() { return false; }\n @Override public T getValue() { return value; }\n @Override public E getError() {\n throw new IllegalStateException(\"No error in Success\");\n }\n @Override public T getOrElse(T defaultValue) { return value; }\n}\n\npublic record SimpleFailure(E error) implements SimpleResult {\n @Override public boolean isSuccess() { return false; }\n @Override public boolean isFailure() { return true; }\n @Override public T getValue() {\n throw new IllegalStateException(\"No value in Failure\");\n }\n @Override public E getError() { return error; }\n @Override public T getOrElse(T defaultValue) { return defaultValue; }\n}\n```\n\n---\n\n### Exercise 2: Add Transformation Methods\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Extend Result with map and flatMap methods.\n\n```java\n// Add to Result interface:\n// - Result map(Function mapper)\n// - Result flatMap(Function> mapper)\n\n// Test with:\nResult parsed = parseNumber(\"42\");\nResult doubled = parsed.map(n -> n * 2);\nResult validated = parsed.flatMap(this::validatePositive);\n```\n\n**✅ Solution:**\n\n```java\npublic sealed interface Result permits Success, Failure {\n\n // ... existing methods ...\n\n Result map(Function mapper);\n Result flatMap(Function> mapper);\n}\n\npublic record Success(T value) implements Result {\n\n @Override\n public Result map(Function mapper) {\n return new Success<>(mapper.apply(value));\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return mapper.apply(value);\n }\n}\n\npublic record Failure(E error) implements Result {\n\n @Override\n @SuppressWarnings(\"unchecked\")\n public Result map(Function mapper) {\n return (Result) this; // Propagate failure\n }\n\n @Override\n @SuppressWarnings(\"unchecked\")\n public Result flatMap(Function> mapper) {\n return (Result) this; // Propagate failure\n }\n}\n\n// Usage\npublic Result parseNumber(String input) {\n try {\n return Result.success(Integer.parseInt(input));\n } catch (NumberFormatException e) {\n return Result.failure(\"Not a valid number: \" + input);\n }\n}\n\npublic Result validatePositive(int number) {\n if (number <= 0) {\n return Result.failure(\"Number must be positive\");\n }\n return Result.success(number);\n}\n\n// Chain operations\nResult result = parseNumber(\"42\")\n .map(n -> n * 2)\n .flatMap(this::validatePositive);\n```\n\n---\n\n### Exercise 3: Try Helper\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Create a Try utility that converts exceptions to Results.\n\n```java\n// Create Try.of() that:\n// - Takes a ThrowingSupplier\n// - Returns Result\n// - Catches exceptions and wraps them in Failure\n\nResult config = Try.of(() ->\n objectMapper.readValue(json, Config.class));\n```\n\n**✅ Solution:**\n\n```java\npublic final class Try {\n\n private Try() {}\n\n public static Result of(ThrowingSupplier supplier) {\n try {\n return Result.success(supplier.get());\n } catch (Exception e) {\n return Result.failure(e);\n }\n }\n\n public static Result of(\n ThrowingSupplier supplier,\n Function errorMapper) {\n try {\n return Result.success(supplier.get());\n } catch (Exception e) {\n return Result.failure(errorMapper.apply(e));\n }\n }\n\n public static Result run(ThrowingRunnable runnable) {\n try {\n runnable.run();\n return Result.success(null);\n } catch (Exception e) {\n return Result.failure(e);\n }\n }\n}\n\n@FunctionalInterface\npublic interface ThrowingSupplier {\n T get() throws Exception;\n}\n\n@FunctionalInterface\npublic interface ThrowingRunnable {\n void run() throws Exception;\n}\n\n// Usage\nResult result = Try.of(() ->\n objectMapper.readValue(json, User.class));\n\nResult mapped = Try.of(\n () -> objectMapper.readValue(json, User.class),\n ex -> new ParseError(ex.getMessage())\n);\n\nresult.onSuccess(user -> log.info(\"Parsed: {}\", user))\n .onFailure(ex -> log.error(\"Parse failed\", ex));\n```\n\n---\n\n### Exercise 4: Validation with Error Accumulation\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 25 minutes\n\n**Task:** Create a validation system that collects all errors instead of failing fast.\n\n```java\n// Create Validation that:\n// - Accumulates multiple errors\n// - Provides combine() to merge validations\n// - Converts to Result>\n\nValidation result = Validation.combine(\n validateEmail(user),\n validatePassword(user),\n validateAge(user)\n);\n\nresult.toResult() // Result>\n```\n\n**✅ Solution:**\n\n```java\npublic class Validation {\n private final T value;\n private final List errors;\n\n private Validation(T value, List errors) {\n this.value = value;\n this.errors = List.copyOf(errors);\n }\n\n public static Validation valid(T value) {\n return new Validation<>(value, List.of());\n }\n\n public static Validation invalid(ValidationError error) {\n return new Validation<>(null, List.of(error));\n }\n\n public static Validation invalid(List errors) {\n return new Validation<>(null, errors);\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public List getErrors() {\n return errors;\n }\n\n public Validation merge(Validation other) {\n List combined = new ArrayList<>(this.errors);\n combined.addAll(other.errors);\n T val = this.value != null ? this.value : other.value;\n return new Validation<>(val, combined);\n }\n\n @SafeVarargs\n public static Validation combine(Validation... validations) {\n T value = null;\n List allErrors = new ArrayList<>();\n\n for (Validation v : validations) {\n if (v.value != null) value = v.value;\n allErrors.addAll(v.errors);\n }\n\n return new Validation<>(value, allErrors);\n }\n\n public Result> toResult() {\n if (isValid()) {\n return Result.success(value);\n }\n return Result.failure(errors);\n }\n}\n\npublic record ValidationError(String field, String message) {}\n\n// Validators\npublic class UserValidators {\n\n public static Validation validateEmail(User user) {\n if (user.getEmail() == null || !user.getEmail().contains(\"@\")) {\n return Validation.invalid(new ValidationError(\"email\", \"Invalid email\"));\n }\n return Validation.valid(user);\n }\n\n public static Validation validatePassword(User user) {\n List errors = new ArrayList<>();\n String pwd = user.getPassword();\n\n if (pwd == null || pwd.length() < 8) {\n errors.add(new ValidationError(\"password\", \"At least 8 characters\"));\n }\n if (pwd != null && !pwd.matches(\".*[A-Z].*\")) {\n errors.add(new ValidationError(\"password\", \"Must contain uppercase\"));\n }\n\n return errors.isEmpty() ? Validation.valid(user) : Validation.invalid(errors);\n }\n\n public static Validation validateAge(User user) {\n if (user.getAge() != null && user.getAge() < 18) {\n return Validation.invalid(new ValidationError(\"age\", \"Must be 18+\"));\n }\n return Validation.valid(user);\n }\n}\n\n// Usage\nValidation validation = Validation.combine(\n UserValidators.validateEmail(user),\n UserValidators.validatePassword(user),\n UserValidators.validateAge(user)\n);\n\nResult> result = validation.toResult();\n\nresult.onFailure(errors ->\n errors.forEach(e -> log.warn(\"{}: {}\", e.field(), e.message()))\n);\n```\n\n---\n\n### Exercise 5: Complete Pipeline with Result\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 30 minutes\n\n**Task:** Build a complete data processing pipeline using Result pattern.\n\n```java\n// Create a pipeline that:\n// 1. Reads file content\n// 2. Parses JSON to object\n// 3. Validates the data\n// 4. Transforms the data\n// 5. Saves to database\n// All steps use Result, errors are properly typed\n\nResult result = pipeline.process(\"data.json\");\n```\n\n**✅ Solution:**\n\n```java\npublic sealed interface ProcessingError {\n String getMessage();\n\n record ReadError(String path, String cause) implements ProcessingError {\n @Override public String getMessage() {\n return \"Failed to read \" + path + \": \" + cause;\n }\n }\n\n record ParseError(String details) implements ProcessingError {\n @Override public String getMessage() {\n return \"Parse failed: \" + details;\n }\n }\n\n record ValidationError(List violations) implements ProcessingError {\n @Override public String getMessage() {\n return \"Validation failed: \" + String.join(\", \", violations);\n }\n }\n\n record TransformError(String details) implements ProcessingError {\n @Override public String getMessage() {\n return \"Transform failed: \" + details;\n }\n }\n\n record SaveError(String details) implements ProcessingError {\n @Override public String getMessage() {\n return \"Save failed: \" + details;\n }\n }\n}\n\npublic class DataPipeline {\n private final ObjectMapper mapper;\n private final DataRepository repository;\n\n public Result process(String filePath) {\n return readFile(filePath)\n .flatMap(this::parseJson)\n .flatMap(this::validate)\n .flatMap(this::transform)\n .flatMap(this::save);\n }\n\n private Result readFile(String path) {\n try {\n String content = Files.readString(Path.of(path));\n return Result.success(content);\n } catch (IOException e) {\n return Result.failure(new ProcessingError.ReadError(path, e.getMessage()));\n }\n }\n\n private Result parseJson(String json) {\n try {\n RawData data = mapper.readValue(json, RawData.class);\n return Result.success(data);\n } catch (JsonProcessingException e) {\n return Result.failure(new ProcessingError.ParseError(e.getMessage()));\n }\n }\n\n private Result validate(RawData data) {\n List violations = new ArrayList<>();\n\n if (data.getId() == null) violations.add(\"id required\");\n if (data.getName() == null) violations.add(\"name required\");\n if (data.getValues() == null || data.getValues().isEmpty()) {\n violations.add(\"values required\");\n }\n\n if (!violations.isEmpty()) {\n return Result.failure(new ProcessingError.ValidationError(violations));\n }\n return Result.success(data);\n }\n\n private Result transform(RawData raw) {\n try {\n ProcessedData processed = ProcessedData.builder()\n .id(raw.getId())\n .name(raw.getName().toUpperCase())\n .processedValues(raw.getValues().stream()\n .map(v -> v * 2)\n .toList())\n .processedAt(Instant.now())\n .build();\n return Result.success(processed);\n } catch (Exception e) {\n return Result.failure(new ProcessingError.TransformError(e.getMessage()));\n }\n }\n\n private Result save(ProcessedData data) {\n try {\n repository.save(data);\n return Result.success(data);\n } catch (DataAccessException e) {\n return Result.failure(new ProcessingError.SaveError(e.getMessage()));\n }\n }\n}\n\n// Usage\nDataPipeline pipeline = new DataPipeline(mapper, repository);\n\nResult result = pipeline.process(\"data.json\");\n\nresult\n .onSuccess(data -> log.info(\"Processed: {}\", data.getId()))\n .onFailure(error -> {\n // Pattern match on error type\n switch (error) {\n case ProcessingError.ValidationError ve ->\n log.warn(\"Validation errors: {}\", ve.violations());\n case ProcessingError.ReadError re ->\n log.error(\"File not found: {}\", re.path());\n default ->\n log.error(\"Processing failed: {}\", error.getMessage());\n }\n });\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: What's the advantage of Result over Optional?\n\n**Answer:**\n- **Optional**: Only indicates presence/absence, no error info\n- **Result**: Carries either success value OR error details\n\n```java\nOptional user = findUser(id); // Why is it empty? Not found? Permission denied?\nResult user = findUser(id); // Clear error information\n```\n\n### Q2: When would you NOT use Result pattern?\n\n**Answer:**\n- Simple CRUD operations where failure is exceptional\n- Code that only throws on programmer error\n- When team isn't familiar with functional patterns\n- Performance-critical paths (Result has some overhead)\n- When exceptions provide better stack traces for debugging\n\n---\n\n## 📝 Summary\n\n| Method | Use When |\n|--------|----------|\n| `map()` | Transform success value |\n| `flatMap()` | Chain operations that return Result |\n| `mapError()` | Transform error type |\n| `getOrElse()` | Provide default on failure |\n| `getOrElseThrow()` | Convert to exception |\n| `onSuccess/onFailure` | Side effects |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Exception vs Result mental model diagram | 5 min |\n| Day 3 | Redo Exercise 2 (Transformation Methods) | 20 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Lost Error) | 15 min |\n| Day 30 | Identify one service method that could benefit from Result pattern | 20 min |\n\n---\n\n*Next: [Part 16: Global Error Handling & RFC 7807]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.823551Z","createdAt","2026-06-10T07:19:24.824266Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",17,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",15,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":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":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},72,"Result Pattern","result-pattern",74,"Monads","monads",75,"Functional Error Handling","functional-error-handling",73,"Either","either",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]