public T findByPrimaryKeyRecursive(String valor) {
    T obj = getObjectBlank();
    Columna columna = obj.getMapeo().getColumaPk();
    String query =
        "SELECT * FROM "
            + obj.getMapeo().getNombreTabla()
            + " WHERE "
            + columna.getName()
            + "='"
            + valor
            + "'";
    System.out.println(query);
    ResultSet rs = this.conexion.ejecutarConsulta(query);
    if (sizeResulSet(rs) == 0) {
      return null;
    }

    try {
      rs.beforeFirst();
    } catch (SQLException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    }
    // System.out.println(query);
    return convertAnObject(rs);
  }
  /**
   * Obejto que permite comunicarme con la base de datos
   *
   * @param i objeto que implemente la interfaz Mapeo
   */
  public void insert(T i) {
    i.setMapeo();
    Mapeo mapeo = i.getMapeo();
    ArrayList<Columna> columnas = mapeo.getColumnas();
    String consulta = "INSERT INTO " + mapeo.getNombreTabla() + "(";

    for (int j = 0; j < columnas.size(); j++) {
      Columna c = columnas.get(j);
      if (j == (columnas.size() - 1)) {
        consulta = consulta + c.getName();
      } else {
        consulta = consulta + c.getName() + ",";
      }
    }

    consulta = consulta + ") VALUES (";

    for (int j = 0; j < columnas.size(); j++) {
      try {
        Columna c = columnas.get(j);

        // obtener el metodo get para acceder a los datos
        String texto = c.getRefAtributo().getName();
        String nombreMetodo =
            "get" + Character.toUpperCase(texto.charAt(0)) + texto.substring(1, texto.length());
        ;
        Method metodoGetValor = findMethod(i.getClass().getMethods(), nombreMetodo);
        Object valor = metodoGetValor.invoke(i);

        if (j == (columnas.size() - 1)) {

          consulta = consulta + "'" + valor.toString() + "'";
        } else {
          consulta = consulta + "'" + valor.toString() + "',";
        }
      } catch (IllegalAccessException 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 (InvocationTargetException ex) {
        Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
      }
    }

    consulta = consulta + ");";
    System.out.println(consulta);
    this.conexion.ejecutarQuery(consulta);
  }
  private List<T> arrayToObject(ResultSet r) {
    List<T> lista = new LinkedList<>();
    // Object []lista = new Object[sizeResulSet(r)];
    AbstractMapeo obj = getObjectBlank();
    Columna columna = obj.getMapeo().getColumaPk();

    int i = 0;
    try {
      r.beforeFirst();
      while (r.next()) {
        // T o=convertAnObject(r);
        T o = findByPrimaryKeyRecursive(r.getObject(columna.getName()).toString());
        lista.add(o);
      }
    } catch (SQLException ex) {
      Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
    }
    return lista;
  }
  /**
   * 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;
  }