Abruf von Entitäten aus der DB in einem PropertyEditor

Question

Wenn Sie PropertyEditors mit Spring MVC verwenden, ist es schlecht, sie Entitäten aus der Datenbank abrufen zu lassen? Sollte ich stattdessen eine leere Entität erstellen und ihre Id.

Zum Beispiel für die Entität Employee:

@Entity
@Table(name = "employee")
public class Employee implements GenericEntity<Integer>{

    @Id
    @GeneratedValue
    @Column(name = "employee_id")
    public Integer getEmployeeId() {
        return employeeId;
    }

    public void setEmployeeId(Integer employeeId) {
        this.employeeId = employeeId;
    }

    /** More properties here **/
}

Ist es eine schlechte Idee, die Entität im PropertyEditor unten mit dem folgenden GenericEntityEditor zu holen:

public class GenericEntityEditor<ENTITY extends GenericEntity<Integer>> extends PropertyEditorSupport {

    private GenericDao<ENTITY, Integer> genericDao;

    public GenericEntityEditor(GenericDao<ENTITY, Integer> genericDao) {
        this.genericDao = genericDao;
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        setValue(genericDao.findById(Integer.valueOf(text)));
    }

    @SuppressWarnings("unchecked")
    @Override
    public String getAsText() {
        ENTITY entity = (ENTITY) getValue();
        if(entity == null) {
            return null;
        } 

        return String.valueOf(entity.getId());
    }
}

die im Controller gebunden werden können:

@Controller
public class EmployeeController {
    /** Some Service-layer resources **/

    @Resource
    private EmployeeDao employeeDao; // implements GenericDao<ENTITY, Integer> genericDao

    @SuppressWarnings("unchecked")
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.registerCustomEditor(Employee.class, new GenericEntityEditor(employeeDao));
    }

    /** Some request mapped methods **/

}

Ist es vorzuziehen, einen spezifischeren Ansatz mit einem EmployeeEditor zu verwenden und einfach eine Employee-Entität zu instanziieren und ihre ID festzulegen?

public class EmployeeEditor extends PropertyEditorSupport {

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        Employee employee = new Employee();
        employee.setId(Integer.valueOf(text));
    }

    @SuppressWarnings("unchecked")
    @Override
    public String getAsText() {
        Employee employee = (Employee) getValue();
        if(employee == null) {
            return null;
        } 

        return String.valueOf(employee.getId());
    }
}

Auf diese Weise tun wir nicht einen Roundtrip zur DB jedes Mal, wenn ein Mitarbeiter auf ein Formular vorhanden ist, aber ich bin unsicher, ob dies funktioniert wie erwartet mit Hibernate?

Answer 1

Ich denke, das ist legal. Ich habe diese Technik eine Zeit lang verwendet, und sie hat gut funktioniert.

Aber Spring 3.0 hat ein besseres Konzept. So genannt Konverter (Siehe Kapitel 5.5 Feder 3 Typenumwandlung )

Diese Konverter arbeiten wie Einweg-Eigenschaftseditoren. Aber sie sind Stateless, und aus diesem Grund mehr performat, und kann reuesed werden!

---

Hinzugefügt: Es gibt eine (noch) nicht dokumentiert Funktion von Spring 3.0.>3: der org.springframework.core.convert.support.IdToEntityConverter

Sie wird von der ConcersationServiceFactory automatisch im ConversationService registriert.

Dieser IdToEntityConverter wandelt automatisch alles (Objekt) in eine Entität um, wenn die Entität!! eine statische Methode hat find<entityName> der einen Parameter hat und der Rückgabetyp ist der Typ der Entität.

/**
 * Converts an entity identifier to a entity reference by calling a static finder method
 * on the target entity type.
 *
 * <p>For this converter to match, the finder method must be public, static, have the signature
 * <code>find[EntityName]([IdType])</code>, and return an instance of the desired entity type.
 *
 * @author Keith Donald
 * @since 3.0
 */

Wenn Sie Zweifel haben, wie Sie eine solche statische Finder-Methode in Ihrer Entität implementieren können. Dann werfen Sie einen Blick auf die von Spring Roo generierten Entitäten.