[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":83,"_70":84,"_34":85},"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":19,"_32":33,"_34":35,"_36":37,"_11":38,"_39":-5,"_40":23,"_41":27,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":51,"_53":54,"_55":56,"_57":58,"_59":51,"_60":16,"_61":51,"_62":63,"_64":65,"_66":67,"_68":69},"id","title","Builder and Factory Patterns","slug","clean-code-part-9-builder-factory","excerpt","Master fluent builders, step builders, and factory methods for handling complex object construction with validation and clean APIs.","# Advanced Clean Code Patterns Part 9: Builder & Factory Patterns\n\nWhen object creation becomes complex, Builder and Factory patterns provide clean solutions. This article covers fluent builders, step builders, static factory methods, and Spring integration.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Patterns | Builder, Step Builder, Factory Method, Abstract Factory |\n| Use Cases | Complex construction, many parameters, conditional creation |\n| Tools | Lombok @Builder, Records |\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Fluent Builder\n\n```java\n// ✅ Fluent Builder with validation\npublic class Order {\n private final Long id;\n private final Customer customer;\n private final List items;\n private final ShippingAddress address;\n private final Discount discount;\n\n private Order(Builder builder) {\n this.id = builder.id;\n this.customer = builder.customer;\n this.items = List.copyOf(builder.items);\n this.address = builder.address;\n this.discount = builder.discount != null ? builder.discount : Discount.NONE;\n }\n\n public static Builder builder() {\n return new Builder();\n }\n\n public static class Builder {\n private Long id;\n private Customer customer;\n private List items = new ArrayList<>();\n private ShippingAddress address;\n private Discount discount;\n\n public Builder id(Long id) {\n this.id = id;\n return this;\n }\n\n public Builder customer(Customer customer) {\n this.customer = customer;\n return this;\n }\n\n public Builder addItem(OrderItem item) {\n this.items.add(item);\n return this;\n }\n\n public Builder items(List items) {\n this.items.addAll(items);\n return this;\n }\n\n public Builder shippingAddress(ShippingAddress address) {\n this.address = address;\n return this;\n }\n\n public Builder discount(Discount discount) {\n this.discount = discount;\n return this;\n }\n\n public Order build() {\n validate();\n return new Order(this);\n }\n\n private void validate() {\n Objects.requireNonNull(customer, \"Customer required\");\n Objects.requireNonNull(address, \"Shipping address required\");\n if (items.isEmpty()) {\n throw new IllegalStateException(\"Order must have items\");\n }\n }\n }\n}\n\n// Usage\nOrder order = Order.builder()\n .customer(customer)\n .addItem(new OrderItem(product1, 2))\n .addItem(new OrderItem(product2, 1))\n .shippingAddress(address)\n .discount(vipDiscount)\n .build();\n```\n\n---\n\n### Pattern 2: Step Builder (Compile-Time Safety)\n\n```java\n// ✅ Step Builder - required fields enforced at compile time\npublic class Email {\n private final String to;\n private final String subject;\n private final String body;\n private final List cc;\n\n private Email(String to, String subject, String body, List cc) {\n this.to = to;\n this.subject = subject;\n this.body = body;\n this.cc = cc;\n }\n\n public static ToStep builder() {\n return new Steps();\n }\n\n // Step interfaces\n public interface ToStep {\n SubjectStep to(String to);\n }\n\n public interface SubjectStep {\n BodyStep subject(String subject);\n }\n\n public interface BodyStep {\n BuildStep body(String body);\n }\n\n public interface BuildStep {\n BuildStep cc(String cc);\n Email build();\n }\n\n // Implementation\n private static class Steps implements ToStep, SubjectStep, BodyStep, BuildStep {\n private String to;\n private String subject;\n private String body;\n private List cc = new ArrayList<>();\n\n @Override\n public SubjectStep to(String to) {\n this.to = to;\n return this;\n }\n\n @Override\n public BodyStep subject(String subject) {\n this.subject = subject;\n return this;\n }\n\n @Override\n public BuildStep body(String body) {\n this.body = body;\n return this;\n }\n\n @Override\n public BuildStep cc(String cc) {\n this.cc.add(cc);\n return this;\n }\n\n @Override\n public Email build() {\n return new Email(to, subject, body, List.copyOf(cc));\n }\n }\n}\n\n// Usage - compiler guides you!\nEmail email = Email.builder()\n .to(\"user@example.com\") // Must be first\n .subject(\"Hello\") // Must be second\n .body(\"Welcome!\") // Must be third\n .cc(\"manager@example.com\") // Optional\n .build();\n\n// Won't compile - missing required fields!\n// Email.builder().subject(\"Hello\").build(); // Error!\n```\n\n---\n\n### Pattern 3: Static Factory Methods\n\n```java\n// ✅ Static Factory Methods\npublic class Money {\n private final BigDecimal amount;\n private final Currency currency;\n\n private Money(BigDecimal amount, Currency currency) {\n this.amount = amount;\n this.currency = currency;\n }\n\n // Named constructors - clearer intent\n public static Money of(BigDecimal amount, Currency currency) {\n return new Money(amount, currency);\n }\n\n public static Money dollars(double amount) {\n return new Money(BigDecimal.valueOf(amount), Currency.USD);\n }\n\n public static Money euros(double amount) {\n return new Money(BigDecimal.valueOf(amount), Currency.EUR);\n }\n\n public static Money zero(Currency currency) {\n return new Money(BigDecimal.ZERO, currency);\n }\n\n // Factory that returns subtype\n public static Money parse(String text) {\n // Parse \"100.00 USD\" format\n String[] parts = text.split(\" \");\n return of(new BigDecimal(parts[0]), Currency.valueOf(parts[1]));\n }\n}\n\n// Usage - reads like natural language\nMoney price = Money.dollars(29.99);\nMoney tax = Money.euros(5.00);\nMoney empty = Money.zero(Currency.USD);\n```\n\n---\n\n### Pattern 4: Factory with Spring\n\n```java\n// ✅ Factory with Spring DI\npublic interface PaymentProcessor {\n PaymentResult process(Payment payment);\n}\n\n@Component\npublic class CreditCardProcessor implements PaymentProcessor {\n // ...\n}\n\n@Component\npublic class PayPalProcessor implements PaymentProcessor {\n // ...\n}\n\n@Component\npublic class PaymentProcessorFactory {\n private final Map processors;\n\n public PaymentProcessorFactory(List processorList) {\n this.processors = processorList.stream()\n .collect(Collectors.toMap(\n PaymentProcessor::getType,\n Function.identity()\n ));\n }\n\n public PaymentProcessor getProcessor(PaymentType type) {\n PaymentProcessor processor = processors.get(type);\n if (processor == null) {\n throw new UnsupportedPaymentTypeException(type);\n }\n return processor;\n }\n}\n```\n\n---\n\n### Lombok @Builder\n\n```java\n// ✅ Lombok for simple cases\n@Builder\n@Getter\npublic class CreateOrderRequest {\n private final Long customerId;\n @Builder.Default\n private final List items = new ArrayList<>();\n private final String discountCode;\n @Builder.Default\n private final ShippingMethod shippingMethod = ShippingMethod.STANDARD;\n}\n\n// Usage\nCreateOrderRequest request = CreateOrderRequest.builder()\n .customerId(123L)\n .items(List.of(item1, item2))\n .build();\n```\n\n---\n\n## 🐛 Debug This: The Mutable Builder Trap\n\nA developer reports: \"We're getting random test failures. The same builder creates different objects in different tests!\"\n\n```java\npublic class OrderBuilder {\n private Long customerId;\n private List items = new ArrayList<>();\n private BigDecimal discount = BigDecimal.ZERO;\n\n public OrderBuilder customerId(Long customerId) {\n this.customerId = customerId;\n return this;\n }\n\n public OrderBuilder addItem(OrderItem item) {\n this.items.add(item); // Mutates the list!\n return this;\n }\n\n public OrderBuilder discount(BigDecimal discount) {\n this.discount = discount;\n return this;\n }\n\n public Order build() {\n return new Order(customerId, items, discount);\n }\n}\n\n// Test code - intermittent failures\n@Test\npublic void testOrders() {\n OrderBuilder baseBuilder = new OrderBuilder()\n .customerId(1L)\n .addItem(item1);\n\n Order order1 = baseBuilder.addItem(item2).build(); // 2 items\n Order order2 = baseBuilder.addItem(item3).build(); // Expected: 2 items, Actual: 3 items!\n}\n```\n\n**Why do orders have different items? Find the state mutation bug!**\n\n---\n\n**✅ Solution:**\n\nThe builder is **mutable and reused** - each `addItem()` call modifies the shared `items` list:\n\n1. `baseBuilder.addItem(item2)` - adds item2 to the list (now has item1, item2)\n2. `baseBuilder.addItem(item3)` - adds item3 to the SAME list (now has item1, item2, item3)\n3. Both `order1` and `order2` reference the same mutated list!\n\n**Fix 1: Defensive copy in build()**\n```java\npublic Order build() {\n return new Order(customerId, new ArrayList<>(items), discount);\n}\n```\n\n**Fix 2: Immutable builder (each method returns new builder)**\n```java\npublic OrderBuilder addItem(OrderItem item) {\n OrderBuilder copy = new OrderBuilder();\n copy.customerId = this.customerId;\n copy.items = new ArrayList<>(this.items);\n copy.items.add(item);\n copy.discount = this.discount;\n return copy;\n}\n```\n\n**The lesson:** Builders should either be single-use or return new instances on modification. Mutable shared state causes subtle bugs.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Implement Fluent Builder\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Create a fluent builder for this class.\n\n```java\npublic class Email {\n private final String from;\n private final List to;\n private final List cc;\n private final String subject;\n private final String body;\n private final boolean html;\n private final List attachments;\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class Email {\n // ... fields ...\n\n private Email(Builder builder) {\n this.from = builder.from;\n this.to = List.copyOf(builder.to);\n this.cc = List.copyOf(builder.cc);\n this.subject = builder.subject;\n this.body = builder.body;\n this.html = builder.html;\n this.attachments = List.copyOf(builder.attachments);\n }\n\n public static Builder builder() {\n return new Builder();\n }\n\n public static class Builder {\n private String from;\n private List to = new ArrayList<>();\n private List cc = new ArrayList<>();\n private String subject;\n private String body;\n private boolean html = false;\n private List attachments = new ArrayList<>();\n\n public Builder from(String from) { this.from = from; return this; }\n public Builder to(String... to) { this.to.addAll(Arrays.asList(to)); return this; }\n public Builder cc(String... cc) { this.cc.addAll(Arrays.asList(cc)); return this; }\n public Builder subject(String subject) { this.subject = subject; return this; }\n public Builder body(String body) { this.body = body; return this; }\n public Builder html(boolean html) { this.html = html; return this; }\n public Builder attach(Attachment att) { this.attachments.add(att); return this; }\n\n public Email build() {\n Objects.requireNonNull(from, \"From is required\");\n if (to.isEmpty()) throw new IllegalStateException(\"At least one recipient required\");\n return new Email(this);\n }\n }\n}\n```\n\n---\n\n### Exercise 2: Step Builder Pattern\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a step builder that enforces: customerId → items → build.\n\n```java\n// Usage should be:\nOrder order = Order.builder()\n .customerId(123L) // Must come first\n .addItem(item1) // Required at least one\n .addItem(item2) // Optional additional\n .build(); // Only available after items\n```\n\n**✅ Solution:**\n\n```java\npublic class Order {\n public static CustomerIdStep builder() {\n return new Steps();\n }\n\n public interface CustomerIdStep {\n ItemStep customerId(Long id);\n }\n\n public interface ItemStep {\n ItemStep addItem(OrderItem item);\n BuildStep done();\n }\n\n public interface BuildStep {\n Order build();\n }\n\n private static class Steps implements CustomerIdStep, ItemStep, BuildStep {\n private Long customerId;\n private List items = new ArrayList<>();\n\n public ItemStep customerId(Long id) {\n this.customerId = id;\n return this;\n }\n\n public ItemStep addItem(OrderItem item) {\n items.add(item);\n return this;\n }\n\n public BuildStep done() {\n if (items.isEmpty()) throw new IllegalStateException(\"At least one item required\");\n return this;\n }\n\n public Order build() {\n return new Order(customerId, items);\n }\n }\n}\n```\n\n---\n\n### Exercise 3: Static Factory Methods\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Replace constructors with static factory methods.\n\n```java\npublic class Money {\n private final BigDecimal amount;\n private final Currency currency;\n\n // Multiple constructors - confusing\n public Money(BigDecimal amount, Currency currency) { ... }\n public Money(String amount, String currency) { ... }\n public Money(double amount) { ... } // Assumes USD\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class Money {\n private final BigDecimal amount;\n private final Currency currency;\n\n private Money(BigDecimal amount, Currency currency) {\n this.amount = amount;\n this.currency = currency;\n }\n\n // Named factory methods - clear intent\n public static Money of(BigDecimal amount, Currency currency) {\n return new Money(amount, currency);\n }\n\n public static Money usd(BigDecimal amount) {\n return new Money(amount, Currency.USD);\n }\n\n public static Money parse(String amount, String currencyCode) {\n return new Money(new BigDecimal(amount), Currency.fromCode(currencyCode));\n }\n\n public static Money zero(Currency currency) {\n return new Money(BigDecimal.ZERO, currency);\n }\n\n // Cache common values\n private static final Map ZERO_CACHE = new ConcurrentHashMap<>();\n\n public static Money zero(Currency currency) {\n return ZERO_CACHE.computeIfAbsent(currency, c -> new Money(BigDecimal.ZERO, c));\n }\n}\n```\n\n---\n\n### Exercise 4: Abstract Factory\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create an Abstract Factory for UI components that supports different themes.\n\n**✅ Solution:**\n\n```java\npublic interface UIComponentFactory {\n Button createButton(String text);\n TextField createTextField(String placeholder);\n Dialog createDialog(String title);\n}\n\npublic class LightThemeFactory implements UIComponentFactory {\n public Button createButton(String text) { return new LightButton(text); }\n public TextField createTextField(String placeholder) { return new LightTextField(placeholder); }\n public Dialog createDialog(String title) { return new LightDialog(title); }\n}\n\npublic class DarkThemeFactory implements UIComponentFactory {\n public Button createButton(String text) { return new DarkButton(text); }\n public TextField createTextField(String placeholder) { return new DarkTextField(placeholder); }\n public Dialog createDialog(String title) { return new DarkDialog(title); }\n}\n\n@Service\npublic class FormBuilder {\n private final UIComponentFactory factory;\n\n public FormBuilder(@Qualifier(\"currentTheme\") UIComponentFactory factory) {\n this.factory = factory;\n }\n\n public Form buildLoginForm() {\n return Form.builder()\n .add(factory.createTextField(\"Username\"))\n .add(factory.createTextField(\"Password\"))\n .add(factory.createButton(\"Login\"))\n .build();\n }\n}\n```\n\n---\n\n### Exercise 5: Lombok @Builder with Validation\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Create a Lombok builder with custom validation and defaults.\n\n**✅ Solution:**\n\n```java\n@Getter\n@Builder(builderClassName = \"UserBuilder\", toBuilder = true)\npublic class User {\n @NonNull\n private final String email;\n\n @NonNull\n private final String name;\n\n @Builder.Default\n private final Role role = Role.USER;\n\n @Builder.Default\n private final LocalDateTime createdAt = LocalDateTime.now();\n\n @Singular\n private final List permissions;\n\n // Custom builder validation\n public static class UserBuilder {\n public User build() {\n // Validate before building\n if (email == null || !email.contains(\"@\")) {\n throw new IllegalArgumentException(\"Valid email required\");\n }\n if (name == null || name.isBlank()) {\n throw new IllegalArgumentException(\"Name cannot be blank\");\n }\n return new User(email, name, role, createdAt, permissions);\n }\n }\n}\n\n// Usage\nUser user = User.builder()\n .email(\"john@example.com\")\n .name(\"John\")\n .permission(Permission.READ)\n .permission(Permission.WRITE)\n .build();\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Q1: Builder vs Constructor - when to use each?\n\n**A:**\n- **Constructor**: 1-3 required parameters, all simple types\n- **Builder**: 4+ parameters, optional parameters, complex objects\n- **Rule of thumb**: If you need to look at JavaDoc to understand parameter order, use Builder\n\n### Q2: How do you make builders thread-safe?\n\n**A:**\n- Return new builder instance from each method (immutable builder)\n- Or make builder single-use and not shared\n- Or synchronize access (rarely needed)\n\n### Q3: What's the difference between Static Factory and Factory Method pattern?\n\n**A:**\n- **Static Factory**: Static method that returns instance (`Money.of(100, USD)`)\n- **Factory Method**: Abstract method overridden by subclasses to create objects\n- Static Factory is about naming and caching, Factory Method is about polymorphic creation\n\n---\n\n## 📝 Summary\n\n| Pattern | Use When |\n|---------|----------|\n| Fluent Builder | Many optional params, complex objects |\n| Step Builder | Required fields, compile-time safety |\n| Static Factory | Named construction, caching |\n| Abstract Factory | Family of related objects |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Builder vs Constructor decision table | 5 min |\n| Day 3 | Redo Exercise 1 (Fluent Builder) | 15 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Mutable Builder Trap) | 10 min |\n| Day 30 | Find one constructor in your project that should be a builder | 15 min |\n\n---\n\n*Next: [Part 10: Composition Over Inheritance]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.739341Z","createdAt","2026-06-10T07:19:24.739938Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",9,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder","author",{"_31":54,"_96":56,"_97":98,"_99":100,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5},"category",{"_31":92,"_70":58,"_34":93,"_73":94,"_95":-5},"tags",[76,77,78,79],"series",{"_31":16,"_70":71,"_34":72,"_73":74,"_75":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":89,"_70":90,"_34":91},{"_31":86,"_70":87,"_34":88},{"_31":83,"_70":84,"_34":85},{"_31":80,"_70":81,"_34":82},49,"Factory Pattern","factory-pattern",51,"Design Patterns","design-patterns",50,"Creational Patterns","creational-patterns",48,"Builder Pattern","builder-pattern",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]