How to Use AI to Refactor Legacy Java Code: A Guide for v21

// AI analyzes and modernizes legacy patterns

// ❌ Legacy code - Java 8 style
public class LegacyOrderProcessor {
    private List<Order> orders = new ArrayList<>();
    
    public List<Order> processOrders(List<Order> inputOrders) {
        List<Order> validOrders = new ArrayList<>();
        
        // AI detects: Imperative style, manual null checks
        for (Order order : inputOrders) {
            if (order != null && order.getAmount() != null && 
                order.getAmount().compareTo(BigDecimal.ZERO) > 0) {
                
                // AI detects: Complex nested logic
                if (order.getStatus() == OrderStatus.PENDING) {
                    order.setStatus(OrderStatus.PROCESSING);
                    order.setProcessedAt(new Date());
                    validOrders.add(order);
                }
            }
        }
        return validOrders;
    }
}

// ✅ AI-modernized Java 21 version
public class ModernOrderProcessor {
    
    // AI suggests: Use modern Java 21 features
    public List<Order> processOrders(List<Order> inputOrders) {
        return inputOrders.stream()
            .filter(Objects::nonNull)
            .filter(order -> order.getAmount() != null)
            .filter(order -> order.getAmount().compareTo(BigDecimal.ZERO) > 0)
            .filter(order -> order.getStatus() == OrderStatus.PENDING)
            .peek(this::updateOrderForProcessing) // AI suggests: Side effect isolation
            .toList(); // AI suggests: Java 16+ toList()
    }
    
    // AI extracts method for clarity
    private void updateOrderForProcessing(Order order) {
        order.setStatus(OrderStatus.PROCESSING);
        order.setProcessedAt(Instant.now()); // AI suggests: Modern time API
    }
}

// AI decomposes massive legacy classes

// ❌ Legacy "God Class" - 2000+ lines
public class LegacyCustomerService {
    // AI detects: Multiple responsibilities mixed together
    public Customer createCustomer(CustomerData data) { /* 200 lines */ }
    public void sendEmail(Customer customer) { /* 150 lines */ }
    public void calculateDiscounts(Customer customer) { /* 300 lines */ }
    public void generateReports(Customer customer) { /* 400 lines */ }
    // ... 50+ more methods
}

// ✅ AI-decomposed modern structure
// AI suggests: Single Responsibility Principle
@Service
public class CustomerService {
    private final CustomerRepository customerRepository;
    private final EmailService emailService;
    private final DiscountCalculator discountCalculator;
    
    public CustomerService(CustomerRepository customerRepository,
                          EmailService emailService,
                          DiscountCalculator discountCalculator) {
        this.customerRepository = customerRepository;
        this.emailService = emailService;
        this.discountCalculator = discountCalculator;
    }
    
    public Customer createCustomer(CustomerData data) {
        var customer = Customer.builder() // AI suggests: Builder pattern
            .name(data.name())
            .email(data.email())
            .createdAt(Instant.now())
            .build();
            
        return customerRepository.save(customer);
    }
}

// AI creates separate services for each responsibility
@Service
public class EmailService {
    public void sendWelcomeEmail(Customer customer) {
        // AI suggests: Template method pattern
        var template = emailTemplateRepository.findByType(EMAIL_WELCOME);
        var content = templateEngine.process(template, customer);
        emailSender.send(customer.email(), content);
    }
}

@Component
public class DiscountCalculator {
    // AI suggests: Strategy pattern for different discount types
    private final Map<CustomerType, DiscountStrategy> strategies;
    
    public BigDecimal calculateDiscount(Customer customer, BigDecimal amount) {
        return strategies.get(customer.getType())
            .calculateDiscount(customer, amount);
    }
}

// AI integrates Java 21 features strategically

// AI suggests: Pattern matching for instanceof (Java 16+)
public String processPayment(Payment payment) {
    // ❌ Old switch on type
    switch (payment.getType()) {
        case CREDIT_CARD:
            CreditCardPayment cc = (CreditCardPayment) payment;
            return processCreditCard(cc);
        case PAYPAL:
            PayPalPayment pp = (PayPalPayment) payment;
            return processPayPal(pp);
        default:
            throw new IllegalArgumentException("Unknown payment type");
    }
    
    // ✅ AI suggests: Modern pattern matching
    return switch (payment) {
        case CreditCardPayment(var cardNumber, var expiryDate) -> 
            processCreditCard(cardNumber, expiryDate);
        case PayPalPayment(var email) -> 
            processPayPal(email);
        case null -> 
            throw new IllegalArgumentException("Payment cannot be null");
        default -> 
            throw new IllegalArgumentException("Unknown payment type: " + payment.getClass());
    };
}

// AI suggests: Records for data classes (Java 14+)
public record CustomerSummary(
    String name,
    String email,
    BigDecimal totalSpent,
    LocalDateTime lastOrderDate
) {
    // AI suggests: Compact constructor for validation
    public CustomerSummary {
        Objects.requireNonNull(name, "Name cannot be null");
        Objects.requireNonNull(email, "Email cannot be null");
        if (totalSpent.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Total spent cannot be negative");
        }
    }
}

// AI suggests: Text blocks for SQL (Java 15+)
public class CustomerRepository {
    private static final String COMPLEX_QUERY = """
        SELECT c.id, c.name, c.email,
               COALESCE(SUM(o.total), 0) as total_spent,
               MAX(o.created_at) as last_order_date
        FROM customers c
        LEFT JOIN orders o ON c.id = o.customer_id
        WHERE c.status = 'ACTIVE'
          AND c.created_at >= ?
        GROUP BY c.id, c.name, c.email
        ORDER BY total_spent DESC
        """;
}