Garniture de chaîne de caractères en JPA

La accepté de répondre (en utilisant JPA entité auditeurs /@Garniture annotation) est dangereux. L'appel de la setter de l'extrait de l'entité apparaît de marque de l'entité en tant que sale. Quand j'ai essayé moi-même à une racine au niveau de l'entité (à l'aide de Spring3 /hibernate), il a déclenché des tonnes d'autres mises à jour liées à des entités qui n'étaient pas modifiés au cours de la transaction. C'était un vrai bordel dans la production et le suivi vers le bas pour ce qui est la cause a pris du temps.

À la fin, j'ai choisi d'aller avec l'approche plus directe de la coupe de chacun des champs manuellement à la demande (dans une entité personnalisée-à-domaine mappeur, ou dans l'entité de lecture) similaire à Edwin réponse.

Je suis en utilisant cette méthode, ce qui rend la garniture transparente, sans avoir à utiliser des annotations dans chaque champ de type chaîne.
Dans le même package que vous avez votre session usine de classe (celle que vous utilisez pour obtenir des Séances, e.g org.blablabla.yourpackage.etc.SessionGetter.getSession(), vous devez créer un fichier nommé package-info.java et de mettre ce contenu à l'intérieur:

@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;

Puis vous créez la classe StringUserType dans ce même package:

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;
}
}

Et c'est tout, pas besoin de créer des annotations dans vos haricots, il sera "comme par magie" couper les cordes à chaque fois que vous obtenir les objets de la base de données.

Mettre l'annotation sur la méthode de lecture, réglez le @Acesss à AccessType.De la propriété et de l'assiette au champ de l'aide de la Chaîne.trim() la méthode.

Ou tout simplement mettre la garniture dans la méthode de lecture et toujours l'accès au terrain à travers elle. Il ne va pas pour obtenir de plus simple.

Si vous n'avez pas l'esprit à l'aide de pure mise en veille prolongée et en s'écartant de la JPA standard, vous pouvez utiliser Hibernate @ColumnTransformer à condition que vous ayez une base de données pour faire le travail de

Vous pouvez trouver comment le faire en Hibernation référence:

http://docs.jboss.org/hibernate/core/3.6/reference/en-US/html/mapping.html#mapping-column-read-and-write

J'espère que ça aide!

Si votre domaine exigence états besoins garni d'informations, vous avez besoin de stocker les données dans garnis de valeur. Je ne vois rien de mal à cela.

Modèle De Domaine

Un modèle d'objet de l'
domaine qui intègre le comportement
et de données. (PEAA - Martin Fowler)

Si vous explicitement d'appliquer la règle d'entreprise au niveau base de données, une option est que vous avez un choix de la rédaction d'un déclencheur, vous pouvez utiliser les haut-SQL méthode trim. Mais ce sera comme à l'aide d'une fusée à casser un œuf.