Reflection de getters de um Transfer Object(VO)

private static final long serialVersionUID = 1L;

private int testeInt;

private long testeLong;

private String teste;

private ArrayList arrayList;

private Collection col;

private HashMap hashMap;

private Integer valor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import com.vf.bvf.respautomatica.data.vo.VParecer;

import com.vf.bvf.respautomatica.data.vo.VRegraDominio;

import com.vf.bvf.respautomatica.data.vo.VRegraFaixa;

public static void main(String[] args) {

	Collection dados = new ArrayList();

	VTeste2 vo = new VTeste2();

	vo.setTesteInt(0);
	vo.setTesteLong(10);

	// arraylist

	VParecer vParecer = new VParecer();
	vParecer.setCdGrupoPassosAnalise(1);
	vParecer.setNuPassoAnalise(2);

	vo.setArrayList(new ArrayList());
	vo.getArrayList().add(vParecer);

	vParecer = new VParecer();
	vParecer.setCdGrupoPassosAnalise(2);
	vParecer.setNuPassoAnalise(1);
	vo.getArrayList().add(vParecer);

	// Collection

	VRegraFaixa vFaixa = new VRegraFaixa();
	vFaixa.setCdGrupoPassosAnalise(2);
	vFaixa.setNuPassoAnalise(1);

	vo.setCol(new ArrayList());
	vo.getCol().add(vFaixa);

	// List
	vo.setCol(new ArrayList());

	VRegraDominio vDominio = new VRegraDominio();
	vDominio.setCdGrupoPassosAnalise(2);
	vDominio.setNuPassoAnalise(1);

	vo.setColList(new ArrayList());
	vo.getColList().add(vDominio);

	// HashMap

	vDominio = new VRegraDominio();
	vDominio.setCdGrupoPassosAnalise(3);
	vDominio.setNuPassoAnalise(3);

	vo.setHashMap(new HashMap());
	vo.getHashMap().put("regra1", vDominio);

	vDominio = new VRegraDominio();
	vDominio.setCdGrupoPassosAnalise(4);
	vDominio.setNuPassoAnalise(4);

	vo.getHashMap().put("regra2", vDominio);

	vFaixa = new VRegraFaixa();
	vFaixa.setCdGrupoPassosAnalise(5);
	vFaixa.setNuPassoAnalise(5);

	vo.setMap(new HashMap());
	vo.getMap().put("regraFaixa1", vFaixa);

	vFaixa = new VRegraFaixa();
	vFaixa.setCdGrupoPassosAnalise(6);
	vFaixa.setNuPassoAnalise(6);

	vo.getHashMap().put("regraFaixa2", vFaixa);

	dados.add(vo);

	// List.class.getSuperclass()

	// Executa a reflection
	try {

		TesteReflection teste = new TesteReflection();
		
		teste.reflectColecao(dados);

	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

}

private static final String TIPO_ARRAYLIST = "java.util.ArrayList";

private static final String TIPO_COLLECTION = "java.util.Collection";

private static final String TIPO_LIST = "java.util.List";

private static final String TIPO_VECTOR = "java.util.Vector";
	  
private static final String TIPO_LINKEDLIST = "java.util.LinkedList";

/**
 * Reflection na coleção
 * 
 * @param dados
 * @throws Exception
 */
public void reflectColecao(Collection dados) throws Exception {

	for (Iterator it = dados.iterator(); it.hasNext();) {

		Object obj = (Object) it.next();

		/* captura o primeiro item */
		Class cls = Class.forName(obj.getClass().getName());
		//

/* efetua a reflection no item da lista */
		this.reflectAtributos(cls);

	}
}

/**
 * Reflection nos atributos
 * 
 * @param cls
 * @throws Exception
 */
public void reflectAtributos(Class cls) throws Exception {

	/* varre todos os atributos */
	Field fieldlist[] = cls.getDeclaredFields();

	for (int i = 0; i < fieldlist.length; i++) {

		/* captura os dados do atributo */
		Field fld = fieldlist[i];

		/* verifica se o atributo é uma collection */
		if (this.ehCollection(fld)) {

			/* reflection na classe */
			
			this.reflectColecao(this.obterColecao(fld, cls));

		}

		/* busca o nome do atributo nas entidades */
		// fld.getName()
		System.out.println(">> Nome da entidade(atributo) = "
				+ fld.getName());
		System.out.println(">>> membro da classe = "
				+ fld.getDeclaringClass());
		System.out.println(">>> tipo = " + fld.getType().getName());

		System.out
				.println("*************************************************");

	}
}

/**
 * Identifica se o atributo é uma colecao
 * 
 * @return
 */
private boolean ehCollection(Field atributo) {

	if ((atributo.getType().getName().equalsIgnoreCase(TIPO_ARRAYLIST))
			|| (atributo.getType().getName()
					.equalsIgnoreCase(TIPO_COLLECTION))
			|| (atributo.getType().getName().equalsIgnoreCase(TIPO_LIST))
			|| (atributo.getType().getName().equalsIgnoreCase(TIPO_VECTOR))) {
		return true;
	}
	return false;
}

/**
 * Retorna a coleção para a recursividade
 * 
 * @param atributo
 * @param cls
 * @return
 * @throws Exception
 */

private Collection obterColecao(Field atributo, Class cls) throws Exception {

	String nomeGetter = this.obterGetterParaOAtributo(atributo.getName(),cls);

	
	/* OS ERROS OCORREM na chamada do método invoke  */
	
	Object teste = null;
	if (nomeGetter!=null){
		
		Object[] arguments = new Object [] {};
		Method metodo = cls.getDeclaredMethod(nomeGetter,new Class[0]);	
		
		if (atributo.getType().getName().equalsIgnoreCase(TIPO_ARRAYLIST)) {

			teste =(java.util.ArrayList) metodo.invoke(cls,arguments);

		}

		if (atributo.getType().getName().equalsIgnoreCase(TIPO_COLLECTION)) {

			teste= (java.util.Collection) metodo.invoke(cls,arguments);

		}

		if (atributo.getType().getName().equalsIgnoreCase(TIPO_LIST)) {

			teste =(java.util.List) metodo.invoke(cls,arguments);

		}

		if (atributo.getType().getName().equalsIgnoreCase(TIPO_VECTOR)) {

			teste =(java.util.Vector) metodo.invoke(cls,arguments);

		}

		if (atributo.getType().getName().equalsIgnoreCase(TIPO_LINKEDLIST)) {

			teste =(java.util.LinkedList) metodo.invoke(cls,arguments);

		}
	
	}

	return null;

}

private String obterGetterParaOAtributo(String nomeAtributo, Class cls) {

	String getterProcurado = "get"+nomeAtributo; 
	
	Method methlist[] = cls.getDeclaredMethods();
	for (int i = 0; i < methlist.length; i++) {
		Method m = methlist[i];
		if (getterProcurado.equalsIgnoreCase(m.getName())){
			return m.getName();
		}
	}

	return null;
}