Domanda

Volevo sapere cosa considera la comunità le "migliori pratiche" rispetto alla mappatura delle gerarchie di classe con Spring JDBC.

Non abbiamo la capacità di utilizzare uno strumento ORM a tutto tondo, tuttavia stiamo usando la primavera JDBC per alleviare parte della noiosa natura di JDBC. Una classe che sfruttiamo molto regolarmente è il beanpropertyrowmapper per la sua facilità d'uso e la possibilità di avere l'accesso alla proprietà del fagiolo insensibile dal nostro set di risultati.

Ho una gerarchia di classe che tutte le mappe a un singolo tavolo (adottando l'approccio del tavolo per hiearchy per questa gerarchia di piccola classe). Pertanto, la tabella contiene una colonna ClassID che può essere utilizzata per determinare quale classe dovrebbe effettivamente essere istanziata. Ex. 1 = manager, 2 = dipendente, 3 = appaltatore. Tutti questi sono "persone" ma ogni sottoclasse di persona ha alcuni attributi unici per la loro classe.

Il mio pensiero iniziale è quello di creare una sottoclasse di BeanPropertyOwmapper e provare a iniettare questa logica per dire "se la colonna A = 1 quindi istanzia un manager e quindi eseguire il tuo legame nomrale".

Sembra un approccio ragionevole? Ci sono altri suggerimenti che le persone potrebbero avere che hanno funzionato per te?

Grazie in anticipo per le tue risposte,

Justin N.

È stato utile?

Soluzione

Non sembra che ci sia un posto nella sottoclasse in cui è possibile aggiungere un gancio per cambiare la classe senza copiare completamente l'implementazione di MAPROW () per BeanPropertyrowMapper. Il tuo miglior approccio potrebbe essere quello di creare una classe di rowmapper che delega al beanpropertyrowmapper appropriato.

Per esempio:

    final RowMapper managerMapper = new BeanPropertyRowMapper(Manager.class);
    final RowMapper employeeMapper = new BeanPropertyRowMapper(Employee.class);
    final RowMapper contractorMapper = new BeanPropertyRowMapper(Contractor.class);

    RowMapper rm = new RowMapper()
    {
        @Override
        public Object mapRow(ResultSet rs, int rowNum)
            throws SQLException
        {
            int employeeType = rs.getInt("type");
            switch (employeeType)
            {
                case 1:
                    return managerMapper.mapRow(rs, rowNum); 

                case 2:
                    return employeeMapper.mapRow(rs, rowNum);

                case 3:
                    return contractorMapper.mapRow(rs, rowNum);

                default:
                    break;

            }
        }
    };

Altri suggerimenti

Non sono sicuro che sia la "best practice", ma suggerisco il seguente approccio (senza usare le proprietà di fagioli -> dovrebbe funzionare più velocemente).

Di solito sai che tipo di oggetto ti aspetti di recuperare. Quindi è possibile fornire un mapper di riga corrispondente quando eseguire SQL.

Dichiara su astratto personalizzato Generico Rowmapper e crea una propria mapper di riga per ogni tipo di persona, cioè:

private static abstract class PersonRowMapper<T extends Person> implements RowMapper<T> {

 @Override
 public abstract T mapRow(ResultSet rs, int rowNum) throws SQLException;

 protected void mapBase(ResultSet rs, T person) throws SQLException {
  //base mapping here
 }
}


private static class EmployeeRowMapper extends PersonRowMapper<Employee> {

 @Override
 public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
  Employee e = new Employee();
  mapBase(rs, e);
  //set other specific employee props
 }
}

Con altri approccio puoi dichiarare metodo astratto nel mapper di base per oggetti di scena specifici, cioè

private static abstract class PersonRowMapper<T extends Person> implements RowMapper<T> {
 @Override
 public T mapRow(ResultSet rs, int rowNum) throws SQLException {
  T instance = getInstance();
  //set base props here
  fill(rs, instance);
 }

 //e.g. return new Employee()
 protected abstract T getInstance();
 //fill specific instance props
 protected abstract void fill(ResultSet rs, T instance) throws SQLException;
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top