Validator : quel design pattern ?

public abstract class EntityAbstract extends Serializable { public abstract void validate() throws ValidationException; protected static <E extends AbstractEntity> void validate(ClassValidator<E> validator, E entity) throws ValidationException { InvalidValue[] values = validator.getInvalidValues(entity); if(values != null && values.length > 0) { throw new ValidationException(values); } } }

public final class Entity extends EntityAbstract { private static final ClassValidator<Entity> VALIDATOR = new ClassValidator<Entity>(Entity.class); @Override public void validate() throws ValidationException { validate(VALIDATOR, this); } }

J'ai trouvé un peu mieux, avec la création automatique d'instances de validateurs dans une classe dédiée (ce qui évite de polluer les entités).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	private static final Map<String, ClassValidator<? extends AbstractEntity>> VALIDATORS = Collections
			.synchronizedMap(new TreeMap<String, ClassValidator<? extends AbstractEntity>>());
 
	/**
         * Get (and create if necessary) the validator for an Entity
         * @param <Entity> Entity class
         * @param entity Entity
         * @return Validator for this entity
         */
	private static <Entity extends AbstractEntity> ClassValidator<Entity> getValidator(Entity entity) {
		Class<Entity> clazz = (Class<Entity>) entity.getClass();
		String className = clazz.getName();
		ClassValidator<Entity> validator = null;
		synchronized (VALIDATORS) {
			validator = (ClassValidator<Entity>) VALIDATORS.get(className);
			if (validator == null) {
				validator = new ClassValidator<Entity>(clazz);
				VALIDATORS.put(className, validator);
			}
		}
		return validator;
	}

Il reste cependant des avertissements que je ne parviens pas à supprimer :

Unchecked cast from Class<capture#1-of ? extends AbstractEntity> to Class<Entity>
Unchecked cast from ClassValidator<capture#2-of ? extends AbstractEntity> to ClassValidator<Entity>