/*Prog*/ Delphi-Neftalí /*finProg*/(3/5) Generación de un cliente (WebService) en Delphi.

Inicio > Aplicación, Delphi, WebService > (3/5) Generación de un cliente (WebService) en Delphi.

(3/5) Generación de un cliente (WebService) en Delphi.

martes, 28 de enero de 2014 Germán Estévez Dejar un comentario Ir a comentarios

En las dos entradas anteriores de esta serie, hemos planteado el problema y hemos visto cómo generar un WebService en PHP que nos permita acceder a nuestra Base de Datos. Una vez completada la parte Servidor, vamos a comenzar a desarrollar las aplicaciones cliente que van a consumir los datos.

Contenido

1 “ROADMAP” DE LAS ENTRADAS

“ROADMAP” DE LAS ENTRADAS

Siguiendo con nuestra “hoja de ruta”, vamos a desarrollar varios clientes de escritorio en Windows, utilizando diferentes alternativas y posibilidades de las que disponemos.

web-service-overview-1

CLIENTE 1: Delphi6 + Indy + LkJSON

Nuestra primera opción va a ser una aplicación (creada en Delphi 6) que acceda al primer webservice que hemos creado aquí y para ello utilizaremos las librerías Indy.

La dirección base es la siguiente, http://neftali.clubdelphi.com/agenda/listado.php; A esa dirección le añadiremos los parámetros necesarios para obtener los datos que necesitemos.

En este caso la solución es muy simple y basta con utilizar el componente TIdHTTP para acceder a la dirección deseada, incluyendo parámetros, según la respuesta que queramos obtener.
Para tratar la información que nos devuelve el servidor (en JSON) utilizaremos la librería LkJSON de Leonid Koninin, que podéis encontrar en SourceForge, para extraer los datos y recorrerlos de una forma más sencilla. Aprovecharemos para llenar un TClientDataset que nos permita mostrarlos en pantalla utilizando componentes de Base de Datos.

var
  TS:TStrings;
  FResponse: string;
  obj:TlkJSONbase;
  vLevel, i:Integer;
  Str, sURL:String;
  k:Word;
begin
  // Crear el componente para los envíos
  Self.Fhttp := TIDHttp.Create(nil);
  // ini
  Self.Fhttp.HandleRedirects := True;
  Self.Fhttp.ReadTimeout := 5000;
 
  // Crear la estructura de respuesta
  Self.FResp := TStringStream.Create('');
  TS := TStringList.Create;
  // Tratar los parámetros
  if (edtIDUsuario.Text &lt;&gt; '') then begin
    i := StrToIntDef(edtIDUsuario.Text, -5);
    if (i = -1) then begin  // Todos los usuarios
      sURL := DIR_BASE;
    end
    else begin  // Buscamos por ID
      sURL := DIR_BASE + '?user=' + IntToStr(i);
      cbAllUsers.Checked := False;
    end;
  end
  else begin
    if (edtNumRegistros.Value = -1) or (edtNumRegistros.Value &gt; 0)then begin
      sURL := DIR_BASE + '?num=' + IntToStr(edtNumRegistros.Value);
    end
    else begin
      sURL := DIR_BASE;
    end;
  end;
 
  // realizar la peticion
  try
    Self.Fhttp.Post(sURL, TS, Self.FResp);

Como veis el código es bastante simple y fácil de entender. Creamos el componente TidHTTP, añadimos a la dirección base del WebService los parámetros, según los datos que ha seleccionado el usuario y lanzamos la petición.

Habría que capturar los posibles errores en la llamada, pero en este caso nos vamos a centrar en la respuesta y en los casos en que es correcta.

  // realizar la peticion
  try
    Self.Fhttp.Post(sURL, TS, Self.FResp);
    // recoger la respuesta (string)
    FResponse := Self.FResp.DataString;
    // La hacemos visible
    mmResponse.Lines.Text := FResponse;
 
    // Conseguir la cadena formateada (componente LkJSON).
    obj := TlkJSONbase.Create();
    // proteccion
    try
      vLevel := 0;
      obj := TlkJSON.ParseText(FResponse);
      // obtener respuesta formateada
      mmResponseOK.Lines.Text := GenerateReadableText(obj, vLevel);
      // Parsear la respuesta para almacenar los datos en un TClientDataset
      ParseResponse(TlkJSONobject(obj));
    finally
      FreeAndNil(obj);
    end;

Lo que hacemos en este caso es recuperar las respuesta en formato texto (pues es JSON) y después de formatearla (no es necesario, simplemente es para poder ver el resultado de forma más legible), llamamos al procedimiento ParseResponse, que lo que hace es recorrer los registros devueltos y almacenarlos en un TClientDataset (para poder mostrarlos en un DBGrid estandard).

El procedimiento ParseResponse no tienen ningún secreto, y es el que tenéis a continuación.

// Extraer usuarios de la respuesta
procedure TForm1.ParseResponse(AObjResp: TlkJSONobject);
var
  objUserList:TlkJSONlist;
  objUser, objtmp:TlkJSONobject;
  i:integer;
  Str:String;
begin
  // Limpiar el contenido
  cds.EmptyDataSet;
  // Objeto usuarios?
  if (AObjResp.IndexOfName('Usuarios') &lt;&gt; -1) then begin
    // Lo almaceamos en un tipo "lista"
    TlkJSONBase(objUserList) := AObjResp.Field['Usuarios'];
    // Recorrer la lista de usuarios.
    for i := 0 to (objUserList.Count - 1) do begin
      // Objeto usuario
      TlkJSONBase(objUser) := objUserList.Child[i];
      TlkJSONBase(objtmp) := objUser.FieldByIndex[0];
      // Añadimos un registro al CDS
      cds.Append;
      try
        // Recoger los campos del objeto
        cds.FieldByName('id').AsString := VarToStr(objtmp.Field['id'].Value);
        cds.FieldByName('nombre').AsString := VarToStr(objtmp.Field['nombre'].Value);
        cds.FieldByName('apellidos').AsString := VarToStr(objtmp.Field['apellidos'].Value);
        cds.FieldByName('telefono').AsString := VarToStr(objtmp.Field['telefono'].Value);
        cds.FieldByName('extension').AsString := VarToStr(objtmp.Field['extension'].Value);
        cds.FieldByName('departamento').AsString := VarToStr(objtmp.Field['departamento'].Value);
        cds.FieldByName('interno').AsString := VarToStr(objtmp.Field['interno'].Value);
        cds.FieldByName('email').AsString := VarToStr(objtmp.Field['email'].Value);
        // Grabar
        cds.Post;
      finally
        cds.Cancel;
      end;
    end;
  end;
end;

Aquí tenéis un pequeño vídeo del programa de ejemplo funcionando.

Al final os dejo los links para descargar los fuentes y el ejecutable del proyecto.

CLIENTE 2 (Delphi XE5 + Componentes REST):

Para probar este primer Webservice (http://neftali.clubdelphi.com/agenda/listadoREST2.php) he creado otro cliente; En este caso utilizando Delphi XE5.

Las últimas versiones de Delphi (creo recordar que desde la XE2 en adelante) ya poseen integrada una librería para tratar JSON y también componentes específicos para conectarse con servidores REST. En concreto, para este ejemplo vamos a ver que, con pocas líneas de código (casi ninguna) podemos no sólo tratar la respuesta del servidor, sino al igual que hemos hecho antes, rellenar un TClientDataset con los datos recibidos.

Para la petición y la respuesta utilizaremos los componentes REST que he comentado:

RESTRequest1: TRESTRequest;
RESTClient1: TRESTClient;
RESTResponse1: TRESTResponse;

Y para convertir los datos, tenemos otro componente llamado «TRESTResponseDataSetAdapter», que como bien dice su nombre nos hace de adaptador entre la respuesta (en este caso en formato JSON) y un Dataset (TClientDataset).

La forma de utilizar los tres primeros componentes es sencilla.

El componente TRestRequest posee la propiedad Client y la propiedad Response, que se utilizan para asignar los otros 2 componentes.
Si vemos en contenido del DFM (para estos tres componentes) veremos que no tienen nada más que configurar:

  object RESTRequest1: TRESTRequest
    Client = RESTClient1
    Params = &lt;&gt;
    Response = RESTResponse1
    OnAfterExecute = RESTRequest1AfterExecute
    Left = 24
    Top = 440
  end
  object RESTClient1: TRESTClient
    Accept = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
    Params = &lt;&gt;
    HandleRedirects = True
    Left = 80
    Top = 440
  end
  object RESTResponse1: TRESTResponse
    Left = 136
    Top = 440
  end

Sólo nos queda realizar la búsqueda utilizando TRestClient según los parámetros. Para ello yo he creado 2 procedimientos simples:

    procedure SearchUsuarios(AId:integer); overload;
    procedure SearchUsuarios(ANombre:string); overload;

Cuya implementación es muy básica:

procedure TFMain.SearchUsuarios(AId: integer);
var
  sURL:string;
begin
  sURL := URL_BASE + '?user=' + IntToStr(AId);
  RESTClient1.BaseURL := sURL;
  // Busqueda
  RESTRequest1.Execute;
end;
 
procedure TFMain.SearchUsuarios(ANombre: string);
var
  sURL:string;
begin
  sURL := URL_BASE + '?nom=' + ANombre;
  RESTClient1.BaseURL := sURL;
  // Busqueda
  RESTRequest1.Execute;
end;

Como veis, lo único que hacemos es añadir el parámetros necesario a la URL_BASE (dirección de nuestro WebService) y lanzar la petición.
Una vez que la petición se completa, la respuesta llega a nuestro componente TRestResponseAdapter, que «une» nuestro componente de respuesta (TRestResponse) con el componente Dataset (TClientDataSet). Si Hemos realizado la definición de campos de forma correcta, tendremos automáticamente los registros que devuelve la petición en nuestro TClientDataset (facil y límpio).

Para este ejemplo, he modificado el fichero del Webservice (el nuevo está en listadoREST.php) para que los parámetros sean más fáciles de recoger con el componentes TRESTResponseDatasetAdapter, y además lo he ampliado (en el fichero listadoREST2.php) con una búsqueda (un nuevo parámetro) por el campo nombre. Para ello se tiene en cuenta un nuevo parámetro nom, y se realiza un LIKE sobre la tabla de usuarios, utilizando caracteres comodín.

Aquí podéis ver un pequeño vídeo del proyecto en el IDE y del mismo funcionando.

CLIENTE 3 (Delphi XE5 + Componentes SOAP)

Como tercer ejemplo voy a realizar una aplicación, utilizando los componentes SOAP. En este caso necesito importar el fichero WSDL y generar la unit que me permitirá acceder a los métodos creados en el Servidor de forma sencilla. En la entrada en que generamos nuestro servidor, vimos al final una variante utilizando la librería nuSOAP, para poder generar de forma automática este fichero. Este fichero será el que utilizaremos para importarlo desde Delphi.

Para importar el fichero WSDL lo podemos realizar desde Delphi utilizando el asistente «Import WSDL»; Se encuentra en el menú File/New/Other en la pestaña de WebServices.

Aquí podéis ver dos imágenes del proceso de Importación. Una vez que tenemos la unit generada queda añadida a nuestro proyecto. Podemos ver, ya en el momento de la generación las estructuras complejas definidas para los datos y los métodos definidos en nuestro WebService.

Para realizar la comunicación vamos a utilizar el componente THTTPRIO. Configuramos la dirección del fichero WSDL y las propiedades Port y Service que nos ofrece el componente.

Definimos un array de objetos (utilizando las clases definidas en el WebService) para recibir la lista de usuarios y realizamos la llamada utilizando algunos de los métodos definidos: ConsultaUsuario o ConsultaUsuarios.

var
  arr:ArregloDeEstructuras;
  info:Estructura;
  l, i:Integer;
begin
  // Según el rellenado llamamos a uno u otro
  if (edtId.Text &lt;&gt; '') then begin
    arr := (HTTPRIO1 as Consulta_de_usuariosPortType).ConsultaUsuario(
      StrToInt(edtId.text));
  end
  else begin
    arr := (HTTPRIO1 as Consulta_de_usuariosPortType).ConsultaUsuarios(
      edtNombre.text);
  end;

Una vez obtenemos la respuesta, lo único que tenemos que hacer es recorrer el array, para tener todos los usuarios que nos ha devuelto la consulta.

Espero que os haya sido útil e interesante. Como los comentarios, sugerencias, críticas y demás, serán bienvenidas.
Os adjunto los links para descargar los tres proyectos (código fuente y ejecutables):

Pues hasta aquí hemos llegado hoy.

Hasta la próxima.

5/5 - (2 votos)

/*Prog*/ Delphi-Neftalí /*finProg*/

(3/5) Generación de un cliente (WebService) en Delphi.

“ROADMAP” DE LAS ENTRADAS

CLIENTE 1: Delphi6 + Indy + LkJSON

CLIENTE 2 (Delphi XE5 + Componentes REST):

CLIENTE 3 (Delphi XE5 + Componentes SOAP)

Post relacionados:

Traducción (by Google)

Stackoverflow en Español

Entradas más populares

Tags

Delphi: Recursos

Delphi: Webs/Blogs

Páginas

Meta

Categories

Blogroll

Archives

Meta

/Prog/ Delphi-Neftalí /finProg/