Gerador de dados Fake

package com.sistema.tests;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

import com.maestro.persistence.exception.EntityFinderException;

/**
 * Classe para teste e log reflexivo dos métodos finder das classes Entity
 * 
 * @author Cláudio Loureiro
 * @version 27/06/2008
 */
public class EntitiesFindersTest {

    private static final String PACKAGE = "com.sistema.persistence.entity";
    
    private static final String[] HOME_CLASS_NAMES = {
        "Classe1Home", // Omiti os nomes reais que são sigilosos
        "Classe2Home",
    };
    
    private static final Map<String, Object> ARGS = loadArgs();
    
    private static final Pattern FINDER_PATTERN = Pattern.compile("^find.*$");
    
//    private static final Pattern GETTER_PATTERN = Pattern.compile("^get.*$");
    
    private static final Pattern ID_PATTERN = Pattern.compile("^.*Id$");
    
    private static final Pattern TYPE_PATTERN = Pattern.compile("^.*Type$");
    
    public EntitiesFindersTest(){
	try {
	    testFinders();
	} catch (Exception e) {
	    e.printStackTrace();
	}
    }
    
    private void testFinders() throws Exception {
	for(String className : HOME_CLASS_NAMES){
	    Class<?> c = Class.forName(PACKAGE+"."+className);
	    Object obj = c.newInstance();
	    System.out.println("---------- ---------- ----------\nEntity:\t"+c.getSimpleName()+"\nFinders:");
	    Method[] methods = c.getMethods();
	    for(Method method : methods){
		if(!FINDER_PATTERN.matcher(method.getName()).matches())continue;
		Object[] parameters = prepareArgs(method.getParameterTypes());
		showFinderLog(method, parameters);
		try{
		    method.invoke(obj, parameters);
		} catch(InvocationTargetException e) {
		    treatInvocationTargetException(e);
		}
	    }
	}
    }

    private Object[] prepareArgs(Class<?>[] parameterTypes) throws Exception {
	if(parameterTypes==null || !(parameterTypes.length>0))return null;
	Object[] args = new Object[parameterTypes.length];
	for(int i=0; i<args.length; i++){
	    Object obj = null;
	    if(ID_PATTERN.matcher(parameterTypes[i].getSimpleName()).matches()){
		obj = parameterTypes[i].newInstance();
		Field[] fields = parameterTypes[i].getDeclaredFields();
		for(int j=0; j<fields.length; j++){
		    fields[j].setAccessible(true);
		    fields[j].set(obj, ARGS.get(fields[j].getType().getSimpleName()));
		}
	    } else if(TYPE_PATTERN.matcher(parameterTypes[i].getSimpleName()).matches()){
		obj = parameterTypes[i].getConstructor(new Class[]{String.class}).newInstance(new Object[]{ARGS.get("StringCode")});
	    } else {
		obj = ARGS.get(parameterTypes[i].getSimpleName());
	    }
	    args[i] = obj;
	}
	return args;
    }

    private void showFinderLog(Method method, Object[] parameters) {
	System.out.print("\t--- "+method.getName()+"(");
	Class<?>[] parameterTypes = method.getParameterTypes();
	for(int i=0; i<parameterTypes.length; i++){
	    System.out.print(parameterTypes[i].getSimpleName()+(i<parameterTypes.length-1?", ":""));
	}
	System.out.print(")(");
	for(int i=0; parameters!=null && i<parameters.length; i++){
	    String parameter = parameters[i]==null?null:ID_PATTERN.matcher(parameters[i].getClass().getSimpleName()).matches()?"id_obj":TYPE_PATTERN.matcher(parameters[i].getClass().getSimpleName()).matches()?"type_obj":parameters[i].toString();
	    System.out.print(parameter+(i<parameters.length-1?", ":""));
	}
	System.out.println(") ---");
    }
    
    private void treatInvocationTargetException(InvocationTargetException e) throws Exception {
        boolean isEntityFinderException = false;
        Throwable t = e;
        while(t!=null) {
            if(t instanceof EntityFinderException) {
                isEntityFinderException = true;
                System.out.println("EntityFinderException - ok");
                break;
            }
            t = t.getCause();
        }
        if(!isEntityFinderException){
            // Eu não preciso da InvocationTargetException, mas da sua causa
            throw (Exception)e.getCause();
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
	new EntitiesFindersTest();
    }

    private static Map<String, Object> loadArgs() {
	Map<String, Object> map = new HashMap<String, Object>();
	
	map.put("StringCode", "01");
	map.put("String", "Teste");
	map.put("Integer", 1);
	map.put("int", 1);
	map.put("Long", 1L);
	map.put("long", 1L);
	map.put("Byte", (byte)1);
	map.put("byte", (byte)1);
	map.put("Float", 1.0F);
	map.put("float", 1.0F);
	map.put("Double", 1.0);
	map.put("double", 1.0);
	map.put("BigDecimal", new BigDecimal(1.0));
	map.put("Date", new java.util.Date());
	
	return map;
    }
    
}

/**
 * Created on 14/07/200815:37:32 
 * FakeGenerator.java
 */
package br.com.emmanuel.santana.application;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;

/**
 * @author emmanuel.santana, ednilson.sobrinho
 * @version 1.0
 *
 */
public class FakeGenerator {
	private static HashMap typeValues = new HashMap();
	
	static {
		typeValues.put("String", "teste");
		typeValues.put("Integer", new Integer(2));
		typeValues.put("Short", new Short((short)2));
		typeValues.put("Long", new Long(2));
		typeValues.put("Date", new Date());
	}
	
	/**
	 * Preenche todos os campos configurados no map com valores fake para teste.
	 * Não preenhce Collection por ser java 1.4 e não foi ainda configurada para preencher campos
	 * primitivos, pois estes já são setadas com o valor padrão
	 * 
	 * @param obj
	 */
	public static void fillBean(Object obj) {
		try {
			Method [] methods = obj.getClass().getDeclaredMethods();
			Field [] fields = obj.getClass().getDeclaredFields();
			
			
			for (int i = 0; i < methods.length; i++) {
				
				if(methods[i].getName().substring(0, 3).equals("set")){
					// field name pego da assinatura do metodo
					String fieldName = (methods[i].getName().substring(3,4)).toLowerCase()+methods[i].getName().substring(4);
					
					for (int j = 0; j < fields.length; j++) {
						// acessar todos os campos
						Field field = fields[j];
						
						if(!field.getType().isPrimitive()) {
							String name = field.getType().getName();
							String type = name.substring(name.lastIndexOf(".")+1);
							// verificar se o metodo pego acima eh o SET de algum dos campos
							if(field.getName().equals(fieldName)){
								System.out.println(fieldName);
								// acessar o mapa para ver que valor atribuir
								Object value = typeValues.get(type);

								if(value == null) {
									// instanciar o objeto e chamar esta mesma funcao recursivamente
									try {
										value = Class.forName(name).newInstance();
										fillBean(value);
									} catch (Exception e) {}
								}
								methods[i].invoke(obj, new Object[]{value});
							}
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Este é um teste da nossa funcionalidade
	 * @param args
	 */
//	public static void main(String[] args) {
//		Pessoa pessoa = new Pessoa();
//		fillBean(pessoa);
//		System.out.println(pessoa);
//	}
}