Validar Atributos de uma Classe

Postado por Ugleiton Carneiro dia 25 de outubro de 2010 as 08:36

Já pensou em validar os atributos de uma classe? Verificar se todos estão preenchidos, sem precisar ficar digitando os atributos um a um...?
Precisei fazer isso essa semana no trabalho, porem eu teria que fazer um código genérico, que iria funcionar em qualquer classe (bean) que eu tivesse criado..
Então depois de umas 6 horas pesquisando, e testanto, descobri o pacote "java.lang.reflect", que possui algumas classes interessantes.
Para validar os atributos utilizei a classe "Method", e como todos os classes (beans) que criei são encapsuladas (utilizam os métodos get e set para acessar os atributos) foi bem simples...

imagine que vc tenha um bean Pessoa

package src.bean;

/**
 *
 * @author Ugleiton
 */
public class Pessoa {
    private String  nome;
    private String  telefone;
    private String  email;
    private int     idade;

    public Pessoa() {
    }

    public Pessoa(String nome, String telefone, String email, int idade) {
        this.nome = nome;
        this.telefone = telefone;
        this.email = email;
        this.idade = idade;
    }

    
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

}

Agora imagine que em alguma tela, antes de salvar no banco de dados, vc deseja verificar se alguns campos foram preenchidos corretamente, dai vc pode utilizar a seguinte classe para validar...
package teste;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import DAO.DAOParametrosValidacao;

/**
 * Classe utilizada para percorrer os metodos getters e verificando o retorno
 * Os valores retornados serão checados de acordo com os parametros do BD
 * @author Ugleiton
 */
public class ValidObject {
    /**
     * obj.getClass().getMethods() retorna um vetor de metodos
     * o for percorre esses métodos verificando os nomes de cada um
     * e valida o retorno de acordo com o tipo.
     * @param Bean que será utilizada para a validação
     * @return Lista com métodos inválidos.
     */
    public static List isValid(Object obj) {
        //utilize um DAO e pegue do banco de dados os parametros desejados, filtrando por nome de BEAN
        //obj.getClass().getSimpleName() é o nome do BEAN 
        List parametros = DAOParametrosValidacao.getParametros(obj.getClass().getSimpleName());
        List metodosInvalidos = new ArrayList();
        if (parametros.size() == 0) {
            return metodosInvalidos;
        }
        for (String p : parametros) {
            for (Method method : obj.getClass().getMethods()) {
                //o nome do métodos começa com get e termina com o nome do parametro do banco
                if (method.getName().startsWith("get") && method.getName().endsWith(p)) {
                    try {
                        //System.out.println("Campo : " + method.getName());
                        if(!isValidObject(method.invoke(obj))){
                            metodosInvalidos.add(method.getName().replace("get", ""));
                        }
                    } catch (Exception ex) {
                    }
                }
            }
        }
        return metodosInvalidos;
    }

    private static boolean isValidObject(Object obj){
        if(obj instanceof Integer){
            return isValidInteger(obj);
        }else if(obj instanceof String){
            return isValidString(obj);
        }else if(obj instanceof BigDecimal){
            return isValidBigDecimal(obj);
        }else{
            throw  new RuntimeException("Tipo não identificado");
        }
    }

    private static boolean isValidInteger(Object obj) {
        Integer valor = (Integer) obj;
        if (valor == 0) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }

    private static boolean isValidBigDecimal(Object obj) {
        BigDecimal valor = (BigDecimal) obj;
        if (valor.compareTo(BigDecimal.ZERO) == 0) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }

    private static boolean isValidString(Object obj) {
        String valor = (String) obj;
        if (valor == null || valor.isEmpty()) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }
}

Como utilizar?

List l = ValidObject.isValid(p);
if (l.size() == 0) {
    System.out.println("campos preenchidos corretamente");
}else{
    String nome = "";
    for (String str : l) {
        nome += str + "\n";
    }
    System.out.println("Campos não Preenchidos corretamente \n" + nome);
}

1 comentários:

Leandro Coelho disse...

Valeu cara, baseado no seu código consegui fazer um teste.

Postar um comentário

Marcadores

Computação (8) Java (7) Excel (2) Humor (2) NetBeans (2) Textos (2) Curiosidades (1) IRPF (1) Musicas (1)