Streamlining CSV Imports with Object-Oriented Design

Building a Structured Importer

Handling external data formats like CSVs often leads to messy, procedural code scattered throughout an application. In the importador_csv project, we recently refactored how data is ingested to move away from loose scripts toward a robust, object-oriented approach.

The Problem: Data Fragmentation

When processing CSV files, the logic to parse rows and the definition of the data entities often become tightly coupled. This leads to "spaghetti code" where business logic is trapped inside file-reading loops, making it impossible to reuse the importer for different data formats or add validation without breaking the flow.

Refactoring for Clarity

We introduced dedicated classes to separate concerns: the Order model, representing the business domain, and the OrderImporter, which handles the transformation logic. By decoupling the file parsing from the entity creation, we ensure that the system is easier to test and maintain.

public class Order {
    private String id;
    private double total;

    public Order(String id, double total) {
        this.id = id;
        this.total = total;
    }
}

public class OrderImporter {
    public Order processRow(String[] data) {
        return new Order(data[0], Double.parseDouble(data[1]));
    }
}

Integrating the Importer

With these abstractions, the Main class becomes a clean orchestrator. Instead of dealing with low-level string parsing, the entry point of the application now interacts with higher-level objects, resulting in cleaner control flow and improved readability.

public class Main {
    public static void main(String[] args) {
        OrderImporter importer = new OrderImporter();
        // The main flow now simply manages the stream of objects
        Order newOrder = importer.processRow(new String[]{"ORD-123", "99.99"});
    }
}

Takeaway

To improve your own data ingestion pipelines, focus on separating your parsing logic from your data models. Create a dedicated service class to handle the transformation layer—this small shift significantly reduces technical debt and makes your codebase much easier to extend as requirements change.

Generated with Gitvlg.com