Question

I’ve got two methods to extract data out of a CSV

private Car processCar (String [] row) {
    Car c = new Car();
    c.setCarId(Integer.parseInt(row[CSVColumns.carid.index]));
    ....
    return c;
}

private Driver processDriver(String[] row) {
    Driver d = new Driver(row[CSVColumns.name.index]);
    sys.setAge(row[CSVColumns.age.index]);
    ...
    return d;
}

Now, while extracting data out of the database I need to again make these two methods, however, with slight changes

private Car processCar (ResultSet rs) {
    Car c = new Car();
    c.setCarId(rs.getInt("Id"));
    ....
    return c;
}

private Driver processDriver(ResultSet) {
    Driver d = new Driver(rs.getString("Name));
    sys.setAge(rs.getString("Age"));
    .....
    return d;
}

Is there a way to simplify this so that I don’t have to repeat myself? Additionally, each method contains a lot of getters/setters so I would hate to copy paste stuff and make changes…

Answer 1

Abstract data source and use common interface

The idea is to have common adapter that translates either ResultSet or CSV into something common behind consistent interface:

interface CarDataSource {

    getCarId();
    //...

}

And two implementations:

class CsvDataSource implements CarDataSource {

    private final String[] row;

    public CsvDataSource(String[] row) {
        this.row = row;
    }

    public int getCarId() {
        return Integer.parseInt(row[CSVColumns.carid.index]);
    }

    //...

}

class ResultSetDataSource implements CarDataSource {

    private final ResultSet rs;

    public ResultSetDataSource(ResultSet rs) {
        this.rs = rs;
    }

    public int getCarId() {
        return Integer.parseInt(rs.getString("Name));
    }

    //...

}

and this is how you use it:

private Car processCar(CarDataSource s) {
    Car c = new Car();
    c.setCarId(s.getCarId());
    ....
    return c;
}

Providing either new CsvDataSource() or new ResultSetDataSource().

Abstract factory with two implementations:

Very similar approach, create and abstract factory:

interface CarFactory {

    Car create();

}

With two implementations:

class CsvCarFactory implements CarFactory {

    private final String[] row;

    public CsvDataSource(String[] row) {
        this.row = row;
    }

    public Car create() {
        Car c = new Car();
        c.setCarId(Integer.parseInt(row[CSVColumns.carid.index]));
        //...
        return c;
    }

}

class ResultSetCarFactory implements CarDataSource {

    private final ResultSet rs;

    public ResultSetCarFactory(ResultSet rs) {
        this.rs = rs;
    }

    public Car create() {
        Car c = new Car();
        c.setCarId(rs.getInt("Id"));
        //...
        return c;
    }

    //...

}

Combination

I don’t like any of the approach above since they introduce a lot of boilerplate without adding much value. But the first approach is promising once you reduce it.

Have just one processCar() that takes String[] as an argument. However if you have a ResultSet, simply translate it first to String[] by extracting columns into subsequent items in arrays:

public String[] toStringArray(ResultSet rs)

The translation in the other direction so that ResultSet is the base format is also possible, but ResultSet is much harder to implement alone.