Discussion :

[CoderInTheDark]

Bonjour,

Je veux rendre la validation de mes bean générique avec une interface et des méthode par défauts.
J'ai écrit le code ci-dessous.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface Validable<T> {
	default Validator getValidator() {
		ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
		return factory.getValidator();
	}
 
public default Set<ConstraintViolation<Class<T>>> validateProperty(String property) {
		return getValidator().validateProperty(T class, property);
	}
 
	public default Set<ConstraintViolation<Validable<T>>> validate() {
		return getValidator().validate(this);
	}
 
	public default boolean isValid() {
		return (validate().isEmpty());
	}
}

Le problème se pose dans la méthode "validateProperty(String property)", qui attend le type de l'objet à valider.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return getValidator().validateProperty(T class, property);

Je ne sais pas comment préciser mon type avec la générécité.
J'aurai voulu écrire T.class
Je ne sais pas si une syntaxe existe pour ça en java 8.

Si vous avez une idée, merci par avance.

Comme alternative je pense qu'on peut écrire une classe utilitaire fgeneric qui retourne cela, mais ça me parait dommage.

Cordialement

[jeffray03]

salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
return getValidator().validateProperty(T t, property);

eric

[CoderInTheDark]

Merci, mais le compilateur me jette toujours.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public interface Validable<T> {
	public default Validator getValidator() {
		ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
		return factory.getValidator();
	}
 
public default Set<ConstraintViolation<Class<T>>> validateProperty(String property) {
return getValidator().validateProperty(T t, property);
	}
 
	public default Set<ConstraintViolation<T>> validateBean() {
		return getValidator().validate(this);
	}
 
	public default boolean isBeanValid() {
		return (validateBean().isEmpty());
	}
 
	public default Set<ConstraintViolation<T>> validateValueForProperty(String property, Object value) { 
return getValidator().validateValue(T t, value);;
	}
 
	public default boolean defaultvalueIsValidForProperty(String property, Object value) {
		return (validateValueForProperty(property, value).isEmpty());
	}
 
}

Messages d'erreurs

Description Resource Path Location Type
Syntax error on token "t", delete this token Validable.java /xComptaCore/src/main/java/fr/xcompta/base line 17 Java Problem
Syntax error on token "t", delete this token Validable.java /xComptaCore/src/main/java/fr/xcompta/base line 29 Java Problem
T cannot be resolved to a variable Validable.java /xComptaCore/src/main/java/fr/xcompta/base line 17 Java Problem
T cannot be resolved to a variable Validable.java /xComptaCore/src/main/java/fr/xcompta/base line 29 Java Problem
Type mismatch: cannot convert from Set<ConstraintViolation<Validable<T>>> to Set<ConstraintViolation<T>> Validable.java /xComptaCore/src/main/java/fr/xcompta/base line 21 Java Problem

[CoderInTheDark]

Bonjour,

Avec une interface je ne sais pas comment intercepter le type de l'objet à valider

Avec un héritage j'ai fait le code ci-dessous.
Là je dois préciser le type de mon bean à la construction à la classe mère.
Mais j'aurai voulu le faire avec une interface en sans préciser le type.

Code de la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public class MonBean extends ValidableBean implements 	 Serializable {
...
public MonBean() {
		super(MonBean.class);
	}
..

Code de la classe mère mutualisant le validation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public abstract class ValidableBean<T> {
	private final Class<T> typeParameterClass;
 
	public ValidableBean(Class<T> typeParameterClass) {
		this.typeParameterClass = typeParameterClass;
	}
 
	private Validator getValidator() {
		ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
		return factory.getValidator();
	}
 
	public Set<ConstraintViolation<ValidableBean<T>>> validate() {
		return getValidator().validate(this);
	}
 
	public boolean isValid() {
		return (validate().isEmpty());
	}
 
	public Set<ConstraintViolation<ValidableBean<T>>> validateProperty(String property) {
		return getValidator().validateProperty(this, property);
	}
 
	public boolean isPropertyValid(String property) {
		return (validateProperty(property).isEmpty());
	}
 
	public Set<ConstraintViolation<T>> validateValue(String property, Object value) {
		return getValidator().validateValue(typeParameterClass, property, value);
	}
 
	public boolean isValueValide(String property, Object value) {
		return (validateValue(property, value).isEmpty());	 
	}

Je me demande aussi si ça apporte un vrai plus.

Pensez-vous que je peux rester sur cette solution ?

Cordialement

[thelvin]

C'est beaucoup trop théorique pour qu'on puisse en juger.

Quand on veut faire du concret :

- d'abord on écrit un exemple de code où un objet est construit, validé et utilisé.
- ensuite on écrit les classes/interfaces/méthodes/hiérarchies qui font cette validation.

[CoderInTheDark]

Désolé en effet je suis un peu confus,
très bien je reprend depuis le début, et je complète avec l'implémentation, mais il faut se référer aux messages précédents pour les autres codes :

Voici une classe métier qui dérive de BeanValidable, dont le code est dans un message précédent.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
@Entity
public class Journal extends ValidableBean implements 	 Serializable {
	protected static final long serialVersionUID = 1L;
 
	@Id
	@NotNull
	@NotBlank
	@Length(min = 2, max = 5)
	protected String code = "";
	@NotNull
	@NotBlank
	@Length(min = 5, max = 50)
	protected String libelle = "";
 
	/**
         * Constructeur vide pour Hibernate
         */
	public Journal() {
		super(Journal.class);
	}
 
	/**
	public Journal(String code, String libelle) {
		super(Journal.class);
 
 
		setCode(code);
		setLibelle(libelle);
	}
 
	public String getCode() {
		return code;
	}
 
	public void setCode(String code) {
		if (code == null) {
			throw new NullPointerException();
		}
 
		this.code = code.trim();
	}
 
	public String getLibelle() {
		return libelle;
	}
 
	public void setLibelle(String libelle) {
		if (libelle == null) {
			throw new NullPointerException();
		}
 
		this.libelle = libelle.trim();
	}
 
...
}

Ce qui me pose problème :
Dans mon constructeur je suis obligé de passer le type de l'objet construit.

Le but est de pouvoir généraliser la validation des beans avec BeanValidator.
Le code est dans la classe mère BeanValidable
Ainsi je peux appeler le code de validation d'un bean depuis le métier les vues et éventuellement les DAO

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
@Test
	public static void main(String [] args) {
initialisation d'un objet avec des valeurs invalides
		Journal journal = new Journal();
		journal.setCode("AC");
		journal.setLibelle("Journal des achats");
 
//Validation global
		Set<ConstraintViolation> constraintViolations = journal.validate();
 
		if(constraintViolations.size() > 0) {
			logger.debug("Liste des erreurs :");
		for (ConstraintViolation constraintViolation : constraintViolations) {
			logger.debug(constraintViolation);
		}
		}
 
//Validation partielle
	Set<ConstraintViolation> constraintViolations = journal.validateProperty("libelle");
 
		if(constraintViolations.size() != 0) {
			logger.debug("Liste des erreurs :");
		for (ConstraintViolation constraintViolation : constraintViolations) {
			logger.debug(constraintViolation);
		}
 
//Validation d'une valeur pour un champs
		Set<ConstraintViolation> constraintViolations = journal.validateValue("code", "A");
 
		if(constraintViolations.size() != 0) {
			logger.debug("Liste des erreurs :");
		for (ConstraintViolation constraintViolation : constraintViolations) {
			logger.debug(constraintViolation);
		}
		}
}
...

Question 1
La solution avec la classe mère fonctionne.
Mais est-il possible de faire inférer le type, pour ne pas à avoir à le setter à la construction du bean qui dérive de "BeanValidable".
Je cherche une solution plus élégante et simple

Question 2
au début je voulais remplacer ma classe mère "BeanValidable" par une interface.
Mais si la solution avec classe mère fonctionne je m'en contenterai
Le problème étant que je ne sais pas comment passer le type de la classe à valider dans ce cas.

Cette solution fonctionne mais je voulais l'améliorer, avec une interface, pour des questions de modélisations


Cordialement