public static AbstractMapeo findLista(AbstractMapeo obj) {
   List<AbstractMapeo> lista = AbstractFacade.getLista();
   for (AbstractMapeo lista1 : lista) {
     if (lista1.equals(obj)) {
       return lista1;
     }
   }
   return null;
 }
 public static Boolean isFindLista(AbstractMapeo obj) {
   List<AbstractMapeo> lista = AbstractFacade.getLista();
   for (AbstractMapeo lista1 : lista) {
     if (lista1.equals(obj)) {
       return true;
     }
   }
   return false;
 }
  /**
   * Funcion que permite realizar la conversion entre tipo de datos de Resulset en Datos
   *
   * @param one variable para saber si
   */
  private T convertAnObject(ResultSet r) {
    // this.contListaObjRef++;
    try {
      if (r.isBeforeFirst()) r.next();
      // while(r.next())
      // {

      T objBlanco = getObjectBlank();
      ArrayList<Columna> columnas = objBlanco.getMapeo().getColumnas();
      for (Columna columna : columnas) {

        Field field = columna.getRefAtributo();
        // System.out.println(columna.getName());

        // field.set(objBlanco,valor);
        String nameAtributo = field.getName();
        char primero = nameAtributo.charAt(0);
        String texto = nameAtributo;
        texto = "set" + Character.toUpperCase(primero) + texto.substring(1, texto.length());
        Method[] metodos = getClassEntity().getMethods();
        // buscar el metodo que coincida con el nombre del atributo con el metodo set
        Method metodoEncontrado = findMethod(getClassEntity().getMethods(), texto);

        // verificar si el valor es directo o es una referencia fk
        String tipoClave = columna.getTypekey();
        if (tipoClave.equals("fk")) {
          String tipo = field.getType().getName();
          Object value = r.getString(columna.getName());

          String nombreClaseReferencia = tipo;
          Class claseReferencia = Class.forName(nombreClaseReferencia);

          /// verificar que el objeto exista no exista en la lista
          Object objReferencia;
          Object tempReferencia = findLista(newObjectPrimaryKey(claseReferencia, value));
          if (tempReferencia != null) {
            objReferencia = tempReferencia;
          } else {
            // cuando no existe el objeto
            Method metodoGetFacade = findMethod(claseReferencia.getMethods(), "getDao");
            Class claseFacade = (Class) metodoGetFacade.invoke(claseReferencia.newInstance());

            Method metodoFindPrimaryKey =
                findMethod(claseFacade.getMethods(), "findByPrimaryKeyRecursive");
            AbstractFacade facadeReferencia = (AbstractFacade) claseFacade.newInstance();
            objReferencia = metodoFindPrimaryKey.invoke(facadeReferencia, value);
            AbstractFacade.addLista((AbstractMapeo) objReferencia);
          }

          // agrega el objeto de referencia al objeto principal
          metodoEncontrado.invoke(objBlanco, objReferencia);

        } else {
          // obtner el valor segun el tipo de dato del atributo

          String tipo = field.getType().getSimpleName();
          String nombreColumna = columna.getName();
          Object value = r.getObject(nombreColumna);
          // System.out.println(value.getClass().getTypeName());
          metodoEncontrado.invoke(objBlanco, value);
        }
      }
      // agregar el objeto a la lista si no se encuentra
      if (!AbstractFacade.isFindLista(objBlanco)) {
        AbstractFacade.addLista(objBlanco);
      }

      //// consultar los arrays enlazados dentro de cada objeto
      List<Lista> areglos = objBlanco.getMapeo().getArrays();
      for (Lista areglo : areglos) {
        Class claseResultado = areglo.getClase();
        String tabla = areglo.getTablaBusqueda();
        String condicion = areglo.getKeyNameFilter();
        // obtener el valor de la clave principal
        Columna columaPk = objBlanco.getMapeo().getColumaPk();
        String texto = columaPk.getName();
        String nombreMetodo =
            "get" + Character.toUpperCase(texto.charAt(0)) + texto.substring(1, texto.length());
        ;
        Method metodoGetValor = findMethod(objBlanco.getClass().getMethods(), nombreMetodo);
        Object valor = metodoGetValor.invoke(objBlanco);
        String consulta =
            "SELECT * FROM " + tabla + " WHERE " + condicion + "='" + valor.toString() + "'";
        System.out.println(consulta);
        ResultSet rs = this.conexion.ejecutarConsulta(consulta);
        // recorrer uno por uno para obtner la variable de la columna que necesito

        int tamnioArray = sizeResulSet(r);
        Object arrayResultado = Array.newInstance(claseResultado, tamnioArray);
        r.beforeFirst();

        int indice = 0;
        while (rs.next()) {
          // obtengo el valor de la columna de que corresponde al objeto de la solucion
          Object valorRespuesta = rs.getObject(areglo.getKeyNameResult());
          Object objResultado;
          Object tempReferencia = findLista(newObjectPrimaryKey(claseResultado, valorRespuesta));
          if (tempReferencia != null) {
            objResultado = tempReferencia;
          } else {
            Object objRes = claseResultado.newInstance();
            Method metodoGetDao = findMethod(objRes.getClass().getMethods(), "getDao");
            Class classDao = (Class) metodoGetDao.invoke(objRes);
            Object objDao = classDao.newInstance();
            Method metodoFindPrimaryKey =
                findMethod(classDao.getMethods(), "findByPrimaryKeyRecursive");

            // ObjectnewObjectPrimaryKey(classDao,valorRespuesta);
            // encuentro un objeto del tipo respuesta para agregar a la lista de referencias
            Method metodoGetObjectBlanck = findMethod(classDao.getMethods(), "getObjectBlank");
            objResultado = metodoGetObjectBlanck.invoke(objDao);
            objResultado = newObjectPrimaryKey(objResultado.getClass(), valorRespuesta);
            AbstractFacade.addLista((AbstractMapeo) objResultado);
            objResultado = metodoFindPrimaryKey.invoke(objDao, valorRespuesta);
          }

          // Array.set(arrayResultado,indice++,claseResultado.cast(objResultado));
          areglo.copyObj(objResultado);
        }

        ////////// convertir de array en una lista para asignar
        // List listaResultado=Arrays.asList(arrayResultado);
        // areglo.copyList((Object[]) arrayResultado);
        // areglo.getKeyNameFilter();

      }

      return objBlanco;
      // }
    } catch (SQLException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IllegalArgumentException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (SecurityException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IllegalAccessException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (InvocationTargetException ex) {
      System.out.println(ex.getCause());
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (ClassNotFoundException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    } catch (InstantiationException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
  }