Na ultima Mundo Java saiu um artigo sobre Hibernate Validator.
Antes da dúvida vamos às classes do exemplo na revista.
O objeto a ser validado era este:
[code]public class Carro {
String cor;
@AssertTrue
boolean ipvaPago;
@AssertFalse
boolean amassado;
}[/code]
A classe que realiza o teste esta:
[code]public class AssertTest {
public static void main(String[] args) {
Carro fuscao = new Carro();
fuscao.cor = "preto";
fuscao.ipvaPago = false;
fuscao.amassado = true;
ClassValidator<Carro> classValidator = new ClassValidator<Carro>(Carro.class);
InvalidValue[] invalidValues = classValidator.getInvalidValues(fuscao);
HandlerTest.printErrors(invalidValues);
fuscao.ipvaPago = true;
fuscao.amassado = false;
invalidValues = classValidator.getInvalidValues(fuscao);
HandlerTest.printErrors(invalidValues);
}
}[/code]
E aqui a classe que simplismente exibe os erros:
[code]public class HandlerTest {
public static void printErrors(InvalidValue[] invalidValues)
{
System.out.println("** Listagem de erros **");
if(invalidValues.length == 0)
System.out.println("Oba! Não há erros\n");
else
print(invalidValues);
}
private static void print(InvalidValue[] invalidValues)
{
Class clazz = invalidValues[0].getBeanClass();
System.out.print("Há " + invalidValues.length);
System.out.println(" erro(s) na entidade: " + clazz.getSimpleName());
for(InvalidValue iv : invalidValues)
{
System.out.print("A propriedade ");
System.out.print(iv.getPropertyName());
System.out.println(" possui o seguinte erro: ");
System.out.println(iv.getMessage());
if(iv.getValue() != null)
{
System.out.print("Valor errado: ");
System.out.println(iv.getValue());
}
}
}
}[/code]
Claro que o Clayton, autor do artigo, simplificou seus exemplos, mas vamos ao que interessa.
Um carro possue seu estado válido quando o ipva está pago e não possui nenhum amassado.
A verificação do estado de um objeto Carro não deveria ser responsabilidade do mesmo?
Assim, ao invés das validações na classe AssertTest, eu simplismente perguntaria ao objeto se ele é valido.
Para ficar mais claro, aqui estão os fontes de como imaginei que seria resumidamente:
[code]public class Car {
private InvalidValue[] invalidValues;
String cor;
@AssertTrue
boolean ipvaPago;
@AssertFalse
boolean amassado;
public void save()
{
System.out.println("Carro salvo!");
}
public void checkState()
{
ClassValidator<Car> classValidator = new ClassValidator<Car>(Car.class);
invalidValues = classValidator.getInvalidValues(this);
if(!(invalidValues == null) && !(invalidValues.length == 0))
throw new IllegalStateException(getErrors());
}
private String getErrors()
{
StringBuilder errors = new StringBuilder();
for(InvalidValue iv : invalidValues)
{
errors.append("\n").append(iv.getMessage())
.append(" (").append(iv.getPropertyName())
.append(" = ").append(iv.getValue()).append(")");
}
return errors.toString();
}
}[/code]
[code]public class AssertTest {
public static void main(String[] args) {
Car fuscao = new Car();
fuscao.cor = "preto";
fuscao.ipvaPago = true;
fuscao.amassado = false;
fuscao.checkState();
fuscao.save();
fuscao.ipvaPago = false;
fuscao.amassado = true;
fuscao.checkState();
fuscao.save();
}
}[/code]
E ai? Faz algum sentido? Quais os prós e contras?
