Trim String-Feld in JPA

Die akzeptierten Antworten (mit JPA entity Listener /@Trim Anmerkung), ist gefährlich. Aufruf der setter auf die abgerufene Einheit angezeigt wird, markieren Sie die Entität als schmutzig. Als ich dies versuchte, mich an einem Wurzel-entity-Ebene (mit Spring3 /hibernate), ausgelöst Tonnen überflüssige updates zu verwandten Organisationen, die sonst nicht geändert werden, während der Transaktion. Es war ein echtes Chaos in der Produktion, und tracking es nach unten, um diese als Ursache nahm sich Zeit.

Am Ende entschied ich mich zu gehen mit den einfacheren Ansatz trimmen Sie die einzelnen Felder manuell on-demand (in einer benutzerdefinierten Entität-zu-domain-mapper, oder in der Entität getter) ähnlich wie Edwin ' s Antwort.

InformationsquelleAutor der Antwort patrickd

Ich bin mit dieser Methode, die macht der Trimm-transparent, ohne Einsatz von Annotationen in jeder string-Feld.
In demselben Paket, das Sie haben Ihre session-factory-Klasse (die, die Sie verwenden, um Sitzungen, e.g org.blablabla.yourpackage.etc.SessionGetter.getSession() haben, müssen Sie erstellen eine Datei mit dem Namen package-info.java und setzen diesen Inhalt:

@TypeDefs({
        @TypeDef(name = "trimmedStringType",
                defaultForType = String.class,
                typeClass = StringUserType.class)
})
package org.blablabla.yourpackage.etc;

import org.hibernate.annotations.TypeDef;
import org.hibernate.annotations.TypeDefs;

Dann erstellen Sie die Klasse StringUserType im gleichen Paket:

import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.usertype.EnhancedUserType;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

public class StringUserType implements EnhancedUserType, Serializable {

    private static final int[] SQL_TYPES = new int[]{Types.VARCHAR};

    @Override
    public int[] sqlTypes() {
        return SQL_TYPES;
    }

    @Override
    public Class returnedClass() {
        return String.class;
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        if (x == y) {
            return true;
        }
        if (x == null || y == null) {
            return false;
        }
        String dtx = (String) x;
        String dty = (String) y;
        return dtx.equals(dty);
    }

    @Override
    public int hashCode(Object object) throws HibernateException {
        return object.hashCode();
    }


    @Override
    public Object nullSafeGet(ResultSet resultSet, String[] names, SessionImplementor session, Object owner)
            throws HibernateException, SQLException {
        Object s = StandardBasicTypes.STRING.nullSafeGet(resultSet, names, session, owner);
        if (s == null) {
            return null;
        }
        return s.toString().trim();
    }

    @Override
    public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SessionImplementor session)
            throws HibernateException, SQLException {
        if (value == null) {
            StandardBasicTypes.STRING.nullSafeSet(preparedStatement, null, index, session);
        } else {
            StandardBasicTypes.STRING.nullSafeSet(preparedStatement, value.toString().trim(), index, session);
        }
    }

    @Override
    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    @Override
    public boolean isMutable() {
        return false;
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        return (Serializable) value;
    }

    @Override
    public Object assemble(Serializable cached, Object value) throws HibernateException {
        return cached;
    }

    @Override
    public Object replace(Object original, Object target, Object owner) throws HibernateException {
        return original;
    }

    @Override
    public String objectToSQLString(Object object) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String toXMLString(Object object) {
        return object.toString();
    }

    @Override
    public Object fromXMLString(String string) {
        return string;
    }

}

Und das ist es, keine Notwendigkeit, erstellen Sie eigene Anmerkungen in deine Bohnen, wird es "magisch" schneiden Sie die Saiten, wenn man die Objekte aus der Datenbank.

InformationsquelleAutor der Antwort Mateus Viccari

Alles, was Sie tun müssen ist, setzen Sie diese auf Ihrem controller, und es funktioniert wie erwartet, brauchen Sie nicht einen listener oder etwas in der

@InitBinder
public void initBinder(WebDataBinder binder) {
    binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
}

InformationsquelleAutor der Antwort Rudy