Refactoring to Patterns in Java: Replace Conditionals, Extract Classes & Eliminate Duplication in Spring Boot

Refactoring is not a luxury or a clean-up task you schedule "after the sprint" — it is a continuous engineering discipline that separates maintainable codebases from legacy nightmares. Martin Fowler's Refactoring catalogue and the Gang of Four design patterns are two sides of the same coin: patterns describe where you want to be, and refactoring techniques describe how to get there safely. This guide walks through ten high-impact refactoring moves with real Spring Boot before/after examples, showing how to replace conditional tangles, extract bloated classes, and eliminate duplication — all without breaking production.

Table of Contents

1. Why Refactoring to Patterns?
2. Replace Conditional with Polymorphism
3. Replace Constructor with Factory Method
4. Replace Type Code with Strategy Pattern
5. Extract Class & Move Method
6. Introduce Parameter Object
7. Replace Temp with Query
8. Decompose Conditional
9. Refactoring Safety: Tests First
10. Refactoring Checklist & Anti-Patterns

// BEFORE: if/else chain — brittle, closed for extension
@Service
public class OrderService {

    public BigDecimal calculateDiscount(Order order, CustomerType customerType) {
        BigDecimal price = order.getTotalPrice();
        if (customerType == CustomerType.GOLD) {
            return price.multiply(new BigDecimal("0.20")); // 20% discount
        } else if (customerType == CustomerType.SILVER) {
            return price.multiply(new BigDecimal("0.10")); // 10% discount
        } else if (customerType == CustomerType.BRONZE) {
            return price.multiply(new BigDecimal("0.05")); // 5% discount
        } else {
            return BigDecimal.ZERO; // no discount
        }
    }
}

// AFTER: Strategy interface + Spring @Component collection
public interface DiscountStrategy {
    CustomerType customerType();
    BigDecimal calculate(BigDecimal price);
}

@Component
public class GoldDiscount implements DiscountStrategy {
    @Override public CustomerType customerType() { return CustomerType.GOLD; }
    @Override public BigDecimal calculate(BigDecimal price) {
        return price.multiply(new BigDecimal("0.20"));
    }
}

@Component
public class SilverDiscount implements DiscountStrategy {
    @Override public CustomerType customerType() { return CustomerType.SILVER; }
    @Override public BigDecimal calculate(BigDecimal price) {
        return price.multiply(new BigDecimal("0.10"));
    }
}

@Component
public class BronzeDiscount implements DiscountStrategy {
    @Override public CustomerType customerType() { return CustomerType.BRONZE; }
    @Override public BigDecimal calculate(BigDecimal price) {
        return price.multiply(new BigDecimal("0.05"));
    }
}

@Service
public class OrderService {
    private final Map<CustomerType, DiscountStrategy> discountMap;

    // Spring injects all DiscountStrategy beans automatically
    public OrderService(List<DiscountStrategy> strategies) {
        this.discountMap = strategies.stream()
            .collect(Collectors.toMap(DiscountStrategy::customerType, s -> s));
    }

    public BigDecimal calculateDiscount(Order order, CustomerType customerType) {
        return discountMap
            .getOrDefault(customerType, price -> BigDecimal.ZERO)
            .calculate(order.getTotalPrice());
    }
}

// BEFORE: Service responsible for account construction
@Service
public class UserAccountService {

    public UserAccount createAccount(String email, AccountType type, String referralCode) {
        UserAccount account;
        if (type == AccountType.PREMIUM) {
            account = new UserAccount(email, AccountType.PREMIUM);
            account.setCreditLimit(new BigDecimal("10000"));
            account.setTrialDays(90);
            account.setFeatures(List.of("ADVANCED_ANALYTICS", "PRIORITY_SUPPORT"));
        } else if (type == AccountType.STANDARD) {
            account = new UserAccount(email, AccountType.STANDARD);
            account.setCreditLimit(new BigDecimal("1000"));
            account.setTrialDays(30);
            account.setFeatures(List.of("BASIC_ANALYTICS"));
        } else {
            account = new UserAccount(email, AccountType.FREE);
            account.setCreditLimit(BigDecimal.ZERO);
            account.setTrialDays(0);
            account.setFeatures(Collections.emptyList());
        }
        if (referralCode != null) {
            account.applyReferralBonus(referralCode);
        }
        return account;
    }
}

// AFTER: Factory handles construction; service handles business logic
@Component
public class AccountFactory {

    public UserAccount create(String email, AccountType type) {
        return switch (type) {
            case PREMIUM  -> buildPremium(email);
            case STANDARD -> buildStandard(email);
            default       -> buildFree(email);
        };
    }

    private UserAccount buildPremium(String email) {
        UserAccount a = new UserAccount(email, AccountType.PREMIUM);
        a.setCreditLimit(new BigDecimal("10000"));
        a.setTrialDays(90);
        a.setFeatures(List.of("ADVANCED_ANALYTICS", "PRIORITY_SUPPORT"));
        return a;
    }

    private UserAccount buildStandard(String email) {
        UserAccount a = new UserAccount(email, AccountType.STANDARD);
        a.setCreditLimit(new BigDecimal("1000"));
        a.setTrialDays(30);
        a.setFeatures(List.of("BASIC_ANALYTICS"));
        return a;
    }

    private UserAccount buildFree(String email) {
        UserAccount a = new UserAccount(email, AccountType.FREE);
        a.setCreditLimit(BigDecimal.ZERO);
        a.setTrialDays(0);
        a.setFeatures(Collections.emptyList());
        return a;
    }
}

@Service
@RequiredArgsConstructor
public class UserAccountService {
    private final AccountFactory accountFactory;
    private final ReferralService referralService;

    public UserAccount createAccount(String email, AccountType type, String referralCode) {
        UserAccount account = accountFactory.create(email, type);
        if (referralCode != null) {
            referralService.applyBonus(account, referralCode);
        }
        return account;
    }
}

// BEFORE: String type code drives branching in every method
@Service
public class PaymentProcessor {

    public PaymentResult charge(String type, BigDecimal amount, String token) {
        if (type.equals("CASH")) {
            return processCash(amount);
        } else if (type.equals("CARD")) {
            return processCard(amount, token);
        } else if (type.equals("CRYPTO")) {
            return processCrypto(amount, token);
        }
        throw new IllegalArgumentException("Unknown payment type: " + type);
    }

    public boolean isRefundable(String type) {
        if (type.equals("CASH"))   return false;
        if (type.equals("CARD"))   return true;
        if (type.equals("CRYPTO")) return true;
        return false;
    }
}

// AFTER: Enum + Strategy + Spring @Qualifier for production wiring

public enum PaymentType { CASH, CARD, CRYPTO }

public interface PaymentProcessor {
    PaymentType supports();
    PaymentResult charge(BigDecimal amount, String token);
    boolean isRefundable();
}

@Component
public class CashPaymentProcessor implements PaymentProcessor {
    @Override public PaymentType supports() { return PaymentType.CASH; }
    @Override public PaymentResult charge(BigDecimal amount, String token) {
        // cash handling — no token needed
        return PaymentResult.success("CASH-" + System.currentTimeMillis());
    }
    @Override public boolean isRefundable() { return false; }
}

@Component
public class CardPaymentProcessor implements PaymentProcessor {
    private final StripeClient stripeClient;
    public CardPaymentProcessor(@Qualifier("stripeClient") StripeClient stripeClient) {
        this.stripeClient = stripeClient;
    }
    @Override public PaymentType supports() { return PaymentType.CARD; }
    @Override public PaymentResult charge(BigDecimal amount, String token) {
        return stripeClient.charge(amount, token);
    }
    @Override public boolean isRefundable() { return true; }
}

@Component
public class CryptoPaymentProcessor implements PaymentProcessor {
    @Override public PaymentType supports() { return PaymentType.CRYPTO; }
    @Override public PaymentResult charge(BigDecimal amount, String token) {
        // blockchain transaction submission
        return PaymentResult.success("CRYPTO-" + UUID.randomUUID());
    }
    @Override public boolean isRefundable() { return true; }
}

@Service
public class PaymentDispatcher {
    private final Map<PaymentType, PaymentProcessor> processors;

    public PaymentDispatcher(List<PaymentProcessor> processorList) {
        this.processors = processorList.stream()
            .collect(Collectors.toMap(PaymentProcessor::supports, p -> p));
    }

    public PaymentResult charge(PaymentType type, BigDecimal amount, String token) {
        return resolve(type).charge(amount, token);
    }

    public boolean isRefundable(PaymentType type) {
        return resolve(type).isRefundable();
    }

    private PaymentProcessor resolve(PaymentType type) {
        PaymentProcessor processor = processors.get(type);
        if (processor == null) throw new UnsupportedPaymentTypeException(type);
        return processor;
    }
}

// BEFORE: 200-line UserService — three concerns tangled together
@Service
public class UserService {

    // --- User management ---
    public User register(RegistrationRequest req) { ... }
    public User findById(UUID id) { ... }
    public void deactivate(UUID id) { ... }

    // --- Address management (separate concern!) ---
    public Address addAddress(UUID userId, AddressRequest req) { ... }
    public List<Address> getAddresses(UUID userId) { ... }
    public Address updateAddress(UUID addressId, AddressRequest req) { ... }
    public void deleteAddress(UUID addressId) { ... }

    // --- Email validation (another separate concern!) ---
    public boolean isValidEmail(String email) { ... }
    public boolean isDomainAllowed(String email) { ... }
    public String normalizeEmail(String email) { ... }
    // ... 170 more lines
}

// AFTER: Three focused classes, each with a single reason to change

// Class diagram (text):
// UserService       ──uses──▶ AddressService
//                  ──uses──▶ EmailValidator
//
// UserService: user lifecycle only
// AddressService: address CRUD only
// EmailValidator: email rules only

@Service
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    private final EmailValidator emailValidator;

    public User register(RegistrationRequest req) {
        emailValidator.validate(req.getEmail());
        User user = User.from(req);
        return userRepository.save(user);
    }

    public User findById(UUID id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }

    public void deactivate(UUID id) {
        User user = findById(id);
        user.deactivate();
        userRepository.save(user);
    }
}

@Service
@RequiredArgsConstructor
public class AddressService {
    private final AddressRepository addressRepository;
    private final UserRepository userRepository;

    public Address addAddress(UUID userId, AddressRequest req) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
        Address address = Address.from(req, user);
        return addressRepository.save(address);
    }

    public List<Address> getAddresses(UUID userId) {
        return addressRepository.findByUserId(userId);
    }

    public Address updateAddress(UUID addressId, AddressRequest req) {
        Address address = addressRepository.findById(addressId)
            .orElseThrow(() -> new AddressNotFoundException(addressId));
        address.update(req);
        return addressRepository.save(address);
    }
}

@Component
public class EmailValidator {
    private static final Pattern EMAIL_PATTERN =
        Pattern.compile("^[\\w._%+\\-]+@[\\w.\\-]+\\.[a-zA-Z]{2,}$");
    private static final Set<String> BLOCKED_DOMAINS =
        Set.of("mailinator.com", "guerrillamail.com");

    public void validate(String email) {
        if (!EMAIL_PATTERN.matcher(email).matches())
            throw new InvalidEmailException(email);
        String domain = email.substring(email.indexOf('@') + 1).toLowerCase();
        if (BLOCKED_DOMAINS.contains(domain))
            throw new BlockedEmailDomainException(domain);
    }

    public String normalize(String email) {
        return email.trim().toLowerCase();
    }
}

// BEFORE: 6-parameter method — confusing, error-prone
@Service
public class OrderPlacementService {

    // Which String is orderId? Which is discountCode? Which is currency?
    public OrderConfirmation placeOrder(
            String orderId,
            Long userId,
            String discountCode,
            String currency,
            Address shippingAddress,
            Address billingAddress) {
        // ...
    }
}

// AFTER: Parameter Object encapsulates the request
public record OrderRequest(
    String orderId,
    Long userId,
    String discountCode,
    String currency,
    Address shippingAddress,
    Address billingAddress
) {
    // Compact constructor adds validation at the boundary
    public OrderRequest {
        Objects.requireNonNull(orderId,          "orderId is required");
        Objects.requireNonNull(userId,           "userId is required");
        Objects.requireNonNull(currency,         "currency is required");
        Objects.requireNonNull(shippingAddress,  "shippingAddress is required");
        if (currency.length() != 3)
            throw new IllegalArgumentException("currency must be ISO 4217 code");
    }

    // billingAddress defaults to shippingAddress when not provided
    public Address effectiveBillingAddress() {
        return billingAddress != null ? billingAddress : shippingAddress;
    }
}

@Service
@RequiredArgsConstructor
public class OrderPlacementService {

    public OrderConfirmation placeOrder(OrderRequest request) {
        // Clean, readable, IDE autocomplete works perfectly
        applyDiscount(request.discountCode(), request.userId());
        return fulfillOrder(request);
    }

    private OrderConfirmation fulfillOrder(OrderRequest request) {
        // ...
        return new OrderConfirmation(request.orderId(), "CONFIRMED");
    }
}

// BEFORE: Temp variable — logic duplicated when needed elsewhere
@Service
public class PricingService {

    public InvoiceLine computeLineItem(OrderItem item) {
        double temp = item.getBasePrice() * (1.0 - item.getDiscountRate());
        if (temp > 100.0) {
            // apply bulk discount
            temp = temp * 0.95;
        }
        double tax = temp * 0.18;
        return new InvoiceLine(item.getSku(), temp, tax);
    }

    public boolean isEligibleForFreeShipping(OrderItem item) {
        // Oops — copy-pasted the same calculation
        double discounted = item.getBasePrice() * (1.0 - item.getDiscountRate());
        return discounted > 50.0;
    }
}

// AFTER: Query methods — single source of truth, self-documenting
@Service
public class PricingService {

    public InvoiceLine computeLineItem(OrderItem item) {
        double netPrice = getNetPrice(item);
        double tax      = getTaxAmount(item);
        return new InvoiceLine(item.getSku(), netPrice, tax);
    }

    public boolean isEligibleForFreeShipping(OrderItem item) {
        return getDiscountedBasePrice(item) > 50.0;
    }

    // --- Query methods: named, reusable, easily testable in isolation ---

    private double getDiscountedBasePrice(OrderItem item) {
        return item.getBasePrice() * (1.0 - item.getDiscountRate());
    }

    private double getNetPrice(OrderItem item) {
        double discounted = getDiscountedBasePrice(item);
        return discounted > 100.0 ? discounted * 0.95 : discounted;
    }

    private double getTaxAmount(OrderItem item) {
        return getNetPrice(item) * 0.18;
    }
}

// BEFORE: Dense compound conditional — hard to read and test
@Service
public class OrderEligibilityService {

    public boolean canFulfill(Order order, Customer customer) {
        if (order.getStatus() == OrderStatus.PENDING
                && customer.getCreditScore() > 600
                && !customer.hasOutstandingBalance()
                && inventoryClient.isAvailable(order.getProductId(), order.getQuantity())
                && order.getDeliveryDate().isAfter(LocalDate.now().plusDays(1))) {
            return true;
        }
        return false;
    }
}

// AFTER: Named predicate methods — reads like business requirements
@Service
@RequiredArgsConstructor
public class OrderEligibilityService {
    private final InventoryClient inventoryClient;

    public boolean canFulfill(Order order, Customer customer) {
        return isOrderPending(order)
            && hasGoodCredit(customer)
            && hasNoPendingBalance(customer)
            && isInStock(order)
            && hasValidDeliveryDate(order);
    }

    private boolean isOrderPending(Order order) {
        return order.getStatus() == OrderStatus.PENDING;
    }

    private boolean hasGoodCredit(Customer customer) {
        return customer.getCreditScore() > 600;
    }

    private boolean hasNoPendingBalance(Customer customer) {
        return !customer.hasOutstandingBalance();
    }

    private boolean isInStock(Order order) {
        return inventoryClient.isAvailable(order.getProductId(), order.getQuantity());
    }

    private boolean hasValidDeliveryDate(Order order) {
        return order.getDeliveryDate().isAfter(LocalDate.now().plusDays(1));
    }
}

// Step 1: Write characterisation tests BEFORE refactoring
@SpringBootTest
class OrderServiceRefactoringTest {

    @Autowired OrderService orderService;

    @Test
    void goldCustomerShouldReceive20PercentDiscount() {
        Order order = Order.of(new BigDecimal("100.00"));
        BigDecimal discount = orderService.calculateDiscount(order, CustomerType.GOLD);
        assertThat(discount).isEqualByComparingTo("20.00");
    }

    @Test
    void silverCustomerShouldReceive10PercentDiscount() {
        Order order = Order.of(new BigDecimal("100.00"));
        BigDecimal discount = orderService.calculateDiscount(order, CustomerType.SILVER);
        assertThat(discount).isEqualByComparingTo("10.00");
    }

    @Test
    void unknownCustomerTypeShouldReceiveZeroDiscount() {
        Order order = Order.of(new BigDecimal("100.00"));
        BigDecimal discount = orderService.calculateDiscount(order, CustomerType.BRONZE);
        assertThat(discount).isEqualByComparingTo("5.00");
    }
}
// All tests pass on the BEFORE code → safe to begin refactoring

Leave a Comment

Related Posts