04creación de Componentes PDF

Componentes con PowerBuilder | 1
Capítulo 4
Desarrollando componentes EAServer con PowerBuilder
En este capítulo vamos a tratar acerca de la creación de los componentes EAServer en

interacción con los clientes PowerBuilder.
Contenido
• Construyendo un componente EAServer en PowerBuilder

• Hacer un deploy a un componente hacia el EAServer desde PowerBuilder
• Conectarse al EAServer desde PowerBuilder
• El objeto Connection
• El wizard del EAServer proxy
• Accesando a un componente EAServer
_____________________________________________________________________________________________
Derechos Reservados de TechEra e-Learning
Este producto solo puede ser usado para uso personal y no para otros fines.
Desarrollo de componentes
Desarrollar aplicaciones para el EAServer, o cualquier otro servidor de aplicaciones, requiere

cambiar en la mente del desarrollador la forma de desarrollar. El desarrollador puede aprender
los términos de componentes en vez del rol de la aplicación en conjunto. En una aplicación
distribuida el sistema está compuesto por muchos componentes que trabajan en conjunto para
solucionar los problemas de negocio. Los componentes pueden necesitar ser diseñados y
construidos para trabajar independientemente, sin embargo, para que estos puedan ser
reusados deben de ser configurados adecuadamente.
El desarrollo de EAServer está enfocado en los componentes. Pueden componerse de uno o

más objetos. Un objeto es un paquete de software compuesto de atributos y métodos. Los
atributos o propiedades describen al objeto y mantienen la información de los métodos que
describen la conducta de un objeto. Los métodos son lógica de negocio y procesos escritos en
los eventos y funciones.
El primer objetivo es construir una aplicación distribuida, para esto se crea una colección de
objetos de negocio reusables. Estos objetos de negocio proveen un área donde las aplicaciones
se desarrollan y rápidamente se vuelve un recurso mayor. Construir aplicaciones usando una
arquitectura basada en objetos reusables decrementa el tiempo de desarrollo de los futuros
proyectos y asegura que la lógica de negocio y los procesos sean consistentes y aplicables a
toda la empresa.
Los componentes que son desplegados a la capa media están compuestos de sus interfaces y
de sus implementaciones. La definición de la interfaz proporciona una descripción del objeto que
incluye el nombre del método, argumentos, y valores de retorno. La definición de la interfaz es
usado para generar un proxy que la aplicación cliente y los objetos pueden usar para acceder a
los componentes. La implementación de la interfaz de un componente es especificado en la
clase del componente y escrito en un lenguaje particular y modelo de componente. Deben
diseñarse objetos de negocio que corran en la capa media para que los métodos que constituyen
la definición de la interfaz proporcionen el acceso fácil a la implementación funcional. La
definición de la interfaz debe ser diseñado para ser robusta y bastante estable para que esto no
requiera cambios cada vez. Los cambios en la funcionalidad de la implementación sin una
modificación en la interfaz de la función permite que todos los cambios en el código sean
manejados en los objetos del servidor de aplicaciones y minimiza el redeploy al cliente.
Los componentes en PowerBuilder
EAServer soporta diferentes modelos de componentes, incluyendo PowerBuilder. El modelo de

componente de PowerBuilder está basado en el custom class user object, comúnmente conocido
como nonvisual user object (NVO). El objeto custom class es usado para construir objetos de
procesos que no tienen propiedades visuales. El NVO es donde se construye una aplicación
distribuida, donde se indica la funcionalidad de acceder y escribir los datos. Tiene funciones y
eventos conocidos como métodos y variables que son conocidos como atributos. El NVO
representa una clase de objeto y es usado para agrupar procesos relacionados y encapsula la
lógica de negocio y funciones del sistema.
El custom class user object es un objeto muy simple derivado desde los objetos de sistema
NonVisualObject de PowerBuilder. Esto no tiene propiedades visuales y contiene solo dos
eventos: El Constructor y el Destructor, también soporta las funciones básicas.
Creando los Componentes EAServer
Para crear una aplicación distribuida con PowerBuilder, tenemos que realizarlo con los wizard
que proporciona PowerBuilder en el tab Target, pero antes de realizar estos temas, tenemos que
_____________________________________________________________________________________________
crear un Workspace, al cual le vamos a poner el nombre de techera4.pbw ( ver figura 4.1),
esto lo realizamos presionando el icono New del Toolbar de PowerBuilder y en el tab Workspace
presionamos el icono Workspace.
Figura 4.1
Crear el Workspace techera4.pbw
Una vez escogido la opción Workspace se ingresa el nombre de techera4.pbw en la ruta

c:\techera\capitulo4 de la ventana de New Workspace como se muestra en la figura 4.2.
Figura 4.2
Ingresando el nombre techera4.pbw
Luego de ingresado el nombre, se generará un archivo de extensión *.pbw, tal como se muestra
en la figura 4.3, este archivo guardará toda la configuración del usuario que trabaje con este
workspace.
Figura 4.3.
Workspace techera4.pbw
_____________________________________________________________________________________________
Creando un profile de EAServer
El profile de EAServer es una opción nueva que fue agregada desde la versión 8.0, esta opción
nos permite acceder a los servidores del EAServer que se van a utilizar como contenedores de
los componentes EAServer desarrollados en PowerBuilder, lo primero que tenemos que hacer es
presionar el icono EAServer Profile (figura 4.4), para poder acceder a la ventana de diálogo
donde vamos a ingresar los servidores.
Figura 4.4
Creando un profile EAServer
Una vez que la ventana de EAServer Profile es activado el siguiente paso para agregar un
servidor es presionar el icono Add..., como se muestra en la figura 4.5, y luego ingresar los
valores del servidor.
Figura 4.5
Asignando un servidor al Profile EAServer
_____________________________________________________________________________________________
Una vez ingresados los valores para el servidor Jaguar, como el nombre del profile (Jaguar),
nombre de servidor (techera o para el caso del lector el nombre de su máquina), número de
puerto (9000) y Login (jagadmin), presionamos el icono Test, para comprobar que los datos
ingresados son los correctos, los nombres ingresados en esta ventana deben coincidir con los
valores que se ingresaron para activar el servidor Jaguar en el Jaguar Manager (explicada en el
capítulo 3), esta opción es mostrada en la figura 4.6.
Figura 4.6
Probando el servidor ingresado
Una vez que el servidor es ingresado al profile de EAServer, desde PowerBuilder debemos de
verificar que efectivamente podemos conectarnos hacia el servidor, esto lo podemos realizar en
el tab page Components del System Tree y en el fólder EAServer Servers podemos ver los
servidores del EAServer Profile, como se muestra en la figura 4.7.
Figura 4.7
_____________________________________________________________________________________________
Verificando los componentes del EAServer
El wizard del componente EAServer
El wizard del componente EAServer ha sido provisto para crear el objeto application y el PBL, así
como el objeto NVO y el objeto project del componente EAServer para hacer deploy a los
componentes. Desde el menú principal de PowerBuilder podemos seleccionar File | New o
presionar el icono New en el PowerBar, esto se ilustra en la figura 4.8.
Figura 4.8
El menú principal de PowerBuilder
Una vez que se ha escogido la opción New del PowerBar, la ventana de diálogo New es
mostrada, en esta ventana vamos a seleccionar el icono de EAServer component, para poder
generar el componente EAServer, tal como se muestra en la figura 4.9.
Figura 4.9
La nueva ventana de diálogo
_____________________________________________________________________________________________
La primera opción que te presenta el wizard del EAServer component es la pantalla sobre las
tareas que debes de realizar luego de creado el componente EAServer, esto es mostrado en la
figura 4.10.
Figura 4.10
Gráfico acerca del wizard del EAServer component
Una vez presionado el botón Next el wizard te muestra los pasos que debes de hacer para
construir una aplicación EAServer (ver figura 4.11).
Figura 4.11
Pasos del wizard del EAServer
_____________________________________________________________________________________________
Ahora debemos de ingresar los nombres respectivos para el objeto application, el nombre y
localización de la librería PowerBuilder (PBL), así como el nombre y ubicación del target
PowerScript. Ingrese la información como se muestra en la figura 4.12, el nombre a ingresar es
operaciones_servidor.
Figura 4.12
El nombre de la aplicación, librería y del target PowerScript
El siguiente paso es ajustar el path del library search. Cualquier librería de PowerBuilder
existente puede ahora adicionarse a la lista de librerías (ver Figura 4.13). El path del library
search puede ser modificado después usando la lista de opciones en el painter del Library y
ubicado en File/librarycan.
Figura 4.13
El path de búsqueda del Library
_____________________________________________________________________________________________
Se puede crear un nuevo componente implementándolo con la interfaz existente de un

componente EAServer. Los métodos de la interfaz EAServer existente deben de ser creados en
el nuevo componente. Si se desea crear una nueva interfaz para el componente entonces
seleccionar la opción Implement New interface, como se muestra en la figura 4.14.
Figura 4.14
Gráfico de la definición de Interfaz
En el prompt de la ventana de diálogo Specify New Component se debe de ingresar un nombre y

una descripción al componente, tal como se muestra en la figura 4.15. El nombre del
componente especificado en la ventana es el nombre del objeto no visual, como debe de
aparecer en la librería PowerBuilder (PBL). Un nombre diferente puede ser definido para el
componente EAServer (ver la figura 4.16). En el ejemplo se emplea el mismo nombre tanto para
el componente EAServer como para el NVO de PowerBuilder, el nombre a ingresar es
n_operaciones.
Figura 4.15
Nombre del componente
_____________________________________________________________________________________________
Figura 4.16
Nombre del componente EAServer
Cuando se define un componente EAServer se debe de haber definido previamente el profile de

servidores EAServers, con la finalidad de poderlos escoger en el Wizard, tal como se muestra en
el figura 4.17, la definición de profile se indica al inicio de este capítulo.
Figura 4.17
Información del Servidor EAServer
_____________________________________________________________________________________________
En el EAServer se instala los componentes dentro de los packages. Los componentes pueden
ser asignados a los packages cuando se utiliza el wizard del componente EAServer o
instalándolos directamente en el servidor EAServer. En el wizard para indicarle un package
existente se puede digitar su nombre o escogerlo de la lista de packages (vea la figura 4.18).
solo los packages instalados en el servidor Jaguar definidos deben de ser listados, nosotros
vamos a ingresar el package operaciones.
Figura 4.18
Nombre del Package
En la siguiente ventana se debe de especificar el tipo de componente, le vamos a indicar que

sea del tipo Standard Componente (por defecto), tal como se muestra en la figura 4.19, mas
acerca de los tipos de componentes son especificados en el capítulo 9.
Figura 4.19
Tipo de Componente
Ahora debemos de configurar la opción del instance pooling, escogiendo esta opción vamos a
permitir que se creen varias instancias del componente en el EAServer, esto permite que cada
usuario que invoque a este componente pueda trabajar con una instancia y cuando lo desactiven
no se destruye y se va al pool de instancias, esta opción se trata en el capítulo 5 (figura 4.20).
Figura 4.20
Opciones del Instance pooling
_____________________________________________________________________________________________
La opción Transaction support determina si un componente deberá usar el Jaguar Transaction

Manager y como el componente se comportará cuando es accedido por otros componentes que
tienen transacciones continuas. En esta parte vamos a escoger la opción Not Supported, porque
no vamos a realizar ninguna transacción, estas opciones son cubiertas en detalle en el capítulo 8
(figura 4.21).
Figura 4.21
La opción Transaction Support
La interfaz de un componente describe como una aplicación cliente y otro componente EAServer
pueden interactuar. EAServer expone todas las funciones públicas en un objeto como parte de la
interfaz. Esta información es almacenada en el Repositorio de EAServer como módulos IDL, esto
es cubierto en el capítulo 3. Todas las funciones expuestas deben de adherirse a la
especificación del IDL de CORBA. Una aplicación cliente y otros componentes EAServer pueden
invocar cualquiera de las funciones expuestas en la interfaz. Un componente PowerBuilder
puede seleccionar para exponer sus user events y publicar sus variables de instancia como parte
de la interfaz en adición a las funciones públicas (vea la figura 4.22).
Figura 4.22
Opciones de Interfaz
_____________________________________________________________________________________________
La opción del Remote debugging y el Live Editing (figura 4.23), brindan grandes opciones al
desarrollador, escogiendo la opción del Remote Debugging en un componente permite al
desarrollador hacer una depuración remota al componente que se encuentra en el EAServer.
Cuando se activa la opción del Live Editing, solo basta con guardar el objeto PowerBuilder para
que sea desplegado al EAServer, esta opción evita que cada vez que se quiere desplegar un
componente se tenga que abrir el objeto project y realizar el despliegue (figura 4.23).
Figura 4.23
Debugging y el live editing
Ahora debemos de asignar el nombre del proyecto en la ventana de diálogo Specify Project,
mostrado en la figura 4.24. El proyecto es donde se almacena toda la información generada por
el wizard. Se usa el proyecto para desplegar al objeto y actualizarlo en el servidor Jaguar. Pero
todos ellos deben de estar instalados en un package. Se puede adicionar componentes
adicionales al proyecto en el painter del proyecto.
En el nombre del project vamos a indicarle p_operaciones_servidor, tal como se muestra en la

figura 4.24.
Figura 4.24
Nombre del Project
_____________________________________________________________________________________________
El paso final antes de terminar con el wizard es especificar las opciones del library usado para
hacer el despliegue (deploy) de los objetos de PowerBuilder al EAServer (vea la figura 4.25). Los
objetos PowerBuilder deben ser instalados en la máquina del servidor Jaguar para que puedan
ser instanciados. Los objetos PowerBuilder son enviados al servidor Jaguar como PowerBuilder
Dynamic Libraries (PBD). La opción PBD es la única opción disponible para hacer deploy, la
opción de machine code (DLL) no es soportada. Esto hace actualmente factible que los objetos
PowerBuilder puedan ser usados en cualquier plataforma. El desarrollador tiene la opción de
enviar o separar el PBD para cada PBL en el library search path del objeto application o
consolidar todos los objetos en un solo PBD. En adición, el desarrollador puede escoger para
incluir los objetos un-referenced en el PBD consolidado. Esto es importante cuando el
componente usa los objetos DataWindow, estos no pueden ser incluidos en el PBD si la opción
es deshabilitada cuando se hace despliegue (deploy) al componente. Una alternativa para usar
la opción Include Unreferenced Objects es especificando los objetos en el PowerBuilder resource
(PBR).
Figura 4.25
Opciones del Dynamic library
Una vez escogido todas las opciones del wizard lo último es revisar las características y hacer
click en el botón Finish, como se muestra en la figura 4.26.
Figura 4.26
El paso final
_____________________________________________________________________________________________
El wizard del componente EAServer debe de crear el Target operaciones_servidor.pbt, la librería

operaciones_servidor.pbl y el archivo operaciones_servidor.pbr. La librería PowerBuilder
operaciones_servidor.pbl contiene los siguientes objetos :
• Objeto application (operaciones_servidor)

• Object project (p_operaciones_servidor)
• User object (n_operaciones)
Programar el objeto Operaciones
Ahora vamos a programar el objeto n_operaciones, el ejemplo de las Operaciones deberá

demostrarte los conceptos básicos para crear una aplicación EAServer. En los siguientes
capítulos detallaremos conceptos más avanzados para poder trabajar en un ambiente distribuido.
La aplicación cliente deberá conectarse al EAServer e invocar al componente de n_operaciones

tal como se ilustra en la figura 4.27. la figura muestra la aplicación corriendo sobre la red. Este
ejemplo también puede ser ejecutado sobre una máquina.
Figura 4.27
Alcances del objeto Operaciones
El wizard ha creado el objeto project para hacer deploy al componente EAServer.
Una vez que se ha desplegado el componente al servidor, ahora debemos de codificar el objeto
nvo creado por el wizard, para esto debemos de abrir el painter del objeto no visual, la manera
más fácil de abrir el painter del User Object es haciendo doble click en el objeto n_operaciones
en el painter del library. También se puede abrir el painter del User Object seleccionando File |
Open desde el menú principal o haciendo click en la opción Open del PowerBar (figura 4.28)
_____________________________________________________________________________________________
Figura 4.28
Icono Open del PowerBar
Cuando se usa las opciones del menú o del PowerBar, se verá una ventana de diálogo abierto,
como se muestra en la figura 4.29. El desarrollador puede escoger cualquier tipo de objeto
PowerBuilder desde el tab PB Object. Para este ejemplo se debe seleccionar la opción del User
Object. Después seleccionar el User Object desde la lista de tipo de Objetos, se debe ver todos
los user objects en el Libraries list. Click en el objeto que se desea abrir y presionar el botón OK.
Esto debe abrir el objeto en el painter apropiado.
Figura 4.29
Ventana de diálogo Open Painter
Figura 4.30
El painter del User Object
_____________________________________________________________________________________________
Una vez abierto el painter del objeto no visual, se debe notar la nueva interfaz que fue
introducida en el PowerBuilder (vea la figura 4.30). para adicionar una nueva función seleccionar
la opción Insert | Function desde el menú principal, o click en el tab del Function List y presionar
el botón derecho para abrir el popup menú. Seleccionar la opción “Add” desde el menú popup,
como se muestra en la figura 4.31.
Figura 4.31
El menú popup de la función
Otra manera de agregar una función es desde el drop-down list box sobre la etiqueta en la hoja
del Script. Después seleccionar las funciones, seleccione la opción New Function desde el drop-
down list box (figura 4.32). Una nueva función puede ser adicionada presionando el botón
derecho en el área del editor del Script donde el drop-down lists box son continuados. Esto
deberá abrir el menú popup que contiene las opciones para adicionar una nueva función, evento,
o parámetros o también borrar una función.
Figura 4.32
Adicionando una nueva función
_____________________________________________________________________________________________
Una vez adicionado una nueva función, ingrese el nombre de la función y especifique el tipo de
retorno como Integer como se muestra en la figura 4.33. El nombre de la función en este ejemplo
es of_calculo. La función acepta 3 argumentos y retorna un integer.
Asígnele 3 argumentos
Paso de valor Tipo argumento Nombre de argumento

Valor INTEGER ai_valor1
Valor INTEGER ai_valor2
Valor STRING as_operador
En el editor del script adicione el siguiente código :
INTEGER li_return
CHOOSE CASE as_operador

CASE '+'
li_return = ai_valor1 + ai_valor2
CASE '-'
li_return = ai_valor1 - ai_valor2
CASE '*'
li_return = ai_valor1 * ai_valor2
CASE '/'
li_return = ai_valor1 / ai_valor2
END CHOOSE
RETURN li_return
Después de finalizar el script para la función of_calculo , grabar el objeto, y con esto se finaliza la
creación del objeto n_operaciones, esto es mostrado en la figura 4.33.
Figura 4.33
La función de Operaciones
_____________________________________________________________________________________________
Una vez que se ha creado una nueva función, realizar las verificaciones respectivas del objeto no
visual y del objeto project para tener todo listo, el siguiente paso es hacer el deploy al
componente creado para que pueda ser instalado en el EAServer, y esté listo para que pueda
ser invocado por las aplicaciones cliente.
Haciendo deploy al objeto EAServer
Una vez que se ha terminado de escribir el objeto n_operaciones se necesita hacer un deploy
hacia el servidor Jaguar. Si se ha usado la opción del wizard para crear el objeto EAServer, ya
se tiene creado el objeto project del componente EAServer. Pero si se ha usado el componente
usando la opción del custom class instanciado del wizard, se necesita crear el objeto project del
componente EAServer.
Si se habilitado la opción del live-editing, el objeto EAServer ya ha sido instalado en el servidor

Jaguar. Cuando esta opción no es implementada, el componente EAServer debe ser desplegado
a través del proyecto. Abrir el objeto project en el painter project, y hacer click en la opción build
(vea la figura 4.34).
Figura 4.34
El project
_____________________________________________________________________________________________
Después de haber completado el deploy, ahora vaya al tab Components y haga un refresh al
fólder EAServer servers y vea al package Operaciones como se muestra en la figura 4.35.
Figura 4.35
El componente instalado en el servidor Jaguar
Luego de haber desplegado el componente con sus métodos al EAServer el siguiente paso es
crear una aplicación cliente que pueda invocar estos componentes, esto se detalla a
continuación.
_____________________________________________________________________________________________
Aplicaciones cliente PowerBuilder
Ahora debemos de crear la aplicación cliente para acceder a los componentes que se
encuentran en el servidor, vamos a utilizar todas los objetos necesarios del PowerBuilder para
crear la interfaz de usuario que va a interactuar con el EAServer este debe contener toda la
lógica de la presentación y los objetos visuales del sistema y deberá ser responsable de la
presentación de la información. La aplicación cliente deberá permitir al usuario iniciar los
procesos de manipulación de datos, de la misma manera como una aplicación cliente/servidor de
dos capas.
Los desarrolladores pueden usar los frames MDI, tab controls, y cualquier otra interfaz de
controles visuales disponibles.
Una de las mayores diferencias, entre una aplicación cliente/servidor y una aplicación EAServer
es remover el acceso a la base de datos desde el cliente, los cambios como un datawindow que
puede ser usado para recuperar y manejar los datos. Otro cambio conocido es el de particionar
una aplicación. Particionar una aplicación involucra separar la lógica en una de las tres capas, la
lógica de la presentación, la lógica de negocio, y la lógica de la base de datos. Los
desarrolladores que han tomado ventaja de particionar la lógica de la aplicación en sus
aplicaciones cliente/servidor o que construyeron aplicaciones clientes con el Distributed
PowerBuilder (DPB), deberían estar familiarizados con estos conceptos. La mayoría de
aplicaciones cliente/servidor PowerBuilder, sin embargo, son construidas con la lógica de
negocio ubicada en un objeto visual, típicamente en el objeto window o en los eventos y
funciones de los DataWindows. Esta forma de tener la presentación y la lógica junta hacen muy
difícil el desarrollo distribuido. Las aplicaciones Distribuidas tienen la lógica de negocio separada
del front-end y los ubican en los non-visual objects (NOVs) y por lo tanto ellos pueden ser
ubicados en la capa media. La aplicación cliente es diseñada para usar objetos distribuidos para
la performance de los procesos y los accesos a los datos.
Construyendo un cliente EAServer en PowerBuilder
PowerBuilder puede ser usado para crear aplicaciones cliente que accedan a componentes en el
servidor Jaguar. La aplicación cliente EAServer deberá ser como cualquier otra aplicación
PowerBuilder, requiriendo de una librería PowerBuilder (PBL), un objeto application y un target.
La ventana de diálogo tiene un Application Wizard en el tab Target para crear aplicaciones
PowerBuilder que te generan un archivo PBL, un objeto application y un target. La ventana de
diálogo es mostrada en la figura 4.36, previamente debemos haber presionado el icono New del
PowerBar.
Figura 4.36
Inicializar el Application Wizard
_____________________________________________________________________________________________
Una vez seleccionado el wizard del application, la ventana de diálogo deberá aparecer pidiendo
información del objeto application (operaciones), nombre del PBL (operaciones.pbl) y nombre del
target (operaciones.pbt) tal como se muestra en la figura 4.37.
Figura 4.37
El target PowerScript, el objeto application y el library
Una vez ingresados los valores presionamos el botón Finish y nos genera los objetos antes
mencionados, los mismos que son mostrados en la figura 4.38.
Figura 4.38
Aplicación Operaciones
Lo primero fue crear la aplicación cliente para acceder al componente en el EAServer, los pasos
siguientes se indican a continuación :
• Construir un objeto connection

• Usar el EAServer proxy wizard para crear un objeto project para generar los objetos
proxies
• Crear los objetos de la interfaz de usuario, incluyendo los windows, menús etc.
• Escribir los scripts para conectar al servidor Jaguar y acceder a los componentes
• Probar la aplicación
_____________________________________________________________________________________________
• Hacer deploy del cliente
Para poder interactuar una aplicación cliente con el EAServer debemos de crear el objeto
Connection, este objeto puede ser creado manualmente o con el Wizard que te provee
PowerBuilder, a continuación detallaremos un poco acerca de este objeto.
El objeto Connection
El cliente se va a comunicar con el servidor mediante el objeto Connection. En este objeto se

debe de especificar los datos necesarios del servidor para poder conectarse, Sin poderse
conectar a un servidor de aplicaciones o servidor de base de datos, nuestras aplicaciones cliente
serían inútiles. Las máquinas que se conectan a una red requieren que ciertas reglas o pautas
sean seguidas para hacer posible la comunicación, si es que estamos hablando de una base de
datos en un modelo de dos capas o un servidor de aplicaciones en una arquitectura distribuida.
Lo que se necesita es un driver, el driver específica el lenguaje o protocolo que se usarán para
transferir la información entre los procesos y las máquinas. Para que cualquiera de las dos
máquinas o procesos puedan comunicarse, deben hablar el mismo idioma. La comunicación
sobre una red puede involucrar varios protocolos que trabajan juntos. Por ejemplo, enviando
requerimientos a una base de datos involucra enviar llamadas SQL/API a la base de datos
usando la sintaxis y formato que este espera. Estos mensajes son enviados sobre la red física,
usando un protocolo de red como el TCP/IP, que asegura que el requerimiento es entregado.
Propiedades del objeto Connection
En el objeto connection es donde se define la información para que una aplicación pueda
establecer conexión con el servidor Jaguar. La información incluye el protocolo de comunicación,
la localización del servidor, y una aplicación específica o puerto del servidor. Cuando se inicializa
el objeto connection, estos detalles son especificados en el driver y propiedades de ubicación.
El Driver
La propiedad del driver le dice al objeto connection que protocolo de red está usando. Al
conectarse al servidor Jaguar, la configuración es siempre Jaguar. Los clientes PowerBuilder
usan el objeto connection para comunicarse con el servidor Jaguar usando el protocolo de
comunicación IIOP. IIOP es un protocolo de comunicación inter-ORB que es ejecutado sobre
TCP/IP. Define la comunicación de objetos y la interacción entre los ORB de CORBA sobre la
red.
El Location
Cuando el driver del Jaguar es especificado, la propiedad location del objeto connection es
usado para determinar la localización del servidor y el número de Puerto. El formato del nombre
del servidor y la resolución es basado sobre el protocolo de red TCP/IP. Esto es un resultado de
la comunicación entre el cliente y el servidor que se manejan a través del IIOP, que se ejecuta
sobre TCP/IP. La sintaxis para la propiedad location es :
<server Name>:<port>
Jaguar también acepta la propiedad location usando la siguiente sintaxis Uniform Resource
Locator (URL) :
iiop://<server name>:<port>
_____________________________________________________________________________________________
El nombre del servidor es definido usando la dirección IP del servidor Jaguar. También puede
listarse con el nombre de la máquina asociado a la dirección IP si el archivo HOST o Domain
Name Services (DNS) está en uso. El puerto es el número de Puerto de un listener IIOP en el
servidor Jaguar. El nombre del servicio puede ser usado en lugar del número de Puerto si esto
fue configurado en el archivo SERVICES.
El User ID, pasword, y el connectstring
El objeto connection tiene tres propiedades de usuario adicionales para hacer las conexiones. El
userid, password, y el connectstring. El objeto connection ignora la propiedad del connectstring
cuando el driver es configurado en el Jaguar.
Las propiedades del User ID y el password son usados para especificar la información login para
el servidor Jaguar. El userid y password no son requeridos para conectarse al servidor Jaguar, a
menos que la opción de autenticación de sistema operativo sea habilitada, o exista un
controlador para manejar las conexiones. El userID también puede ser requerido si el nombre de
usuario tiene asignado roles, packages o componentes que la aplicación intenta usar.
Las propiedades del EAServer connection
La Table 4.1 totaliza las propiedades de conexión para el objeto connection cuando se
relacionan con el EAServer
Tabla 4.1 Propiedades de conexión relacionadas con el EAServer
Propiedad Descripción
Driver El nombre del driver Jaguar. El valor es siempre “Jaguar”
Location El nombre de host y número de Puerto para el servidor Jaguar es separado por
una coma
Application El package default usado para acceder a los componentes EAServer
Connectstring No usado en el Jaguar
UserId El user ID Jaguar
Password El password Jaguar
ErrCode El código de error indicando la falla o satisfacción de la última operación remota
ErrText El texto del error indicando la falla o éxito de la última operación remota
Trace No usado en el Jaguar
Options Una o más configuración de la propiedad Jaguar ORB
Funciones y Eventos del objeto Connection
El objeto Connection tiene tres eventos: Constructor, Destructor, y Error. El más importante de
estos eventos es el error. Este evento es usado para rastrear y manejar los errores (ver la tabla
4.2)
.
Table 4.2 Definiendo los eventos del objeto connection.
Evento Descripción
Constructor Se dispara cuando el objeto es creado
Destructor Se dispara cuando el objeto es destruido
Error Se dispara cuando el servidor no satisface los requerimientos.
El objeto connection tiene muchas funciones. Algunos se relacionan con el Distributed

PowerBuilder (DPB) y algunas son relacionadas con el servidor Jaguar. La Tabla 4.3 define las
funciones usadas por las aplicaciones PowerBuilder cuando acceden al servidor.
_____________________________________________________________________________________________
Tabla 4.3 Funciones del objeto connection usados por PowerBuilder
Función Descripción
ConnectToServer Conecta una aplicación cliente al servidor de aplicaciones, retorno 0 si es
satisfactorio o los códigos de error 50, 52-57, 62,92 si ha fallado.
DisconnectServer Desconecta una aplicación cliente de un servidor de aplicaciones retorna 0
cuando es satisfactorio o los códigos de error 50,52-57,62 cuando falló
CreateInstance Crea una instancia de un objeto en el servidor, retorna 0 si es satisfactorio o
los códigos de error 50,52-57,62 si falló.
Lookup Crea la instancia de un objeto en el servidor Jaguar usando una interfaz del
servidor, retorna 0 cuando es satisfactorio o número negativo cuando falló.
GetContextService Crea una referencia de objeto para el objeto service, retorna 0 si es
satisfactorio ó –1 si falló
Conectándose al Jaguar
Estos son los pasos para que un cliente se conecte al Jaguar:

1. Declare una variable de tipo connection
2. Cree una instancia del objeto connection
3. Inicialice el objeto connection
4. Conéctarse al servidor usando la función ConnectToServer
Estos pasos deben seguirse en ese orden, pero ellos pueden estar en varios scripts. El objeto
connection debería ser una variable global o instancia, para que tenga un alcance en la vida de
la aplicación. PowerBuilder no define por defecto un objeto connection global, así que uno debe
ser creado y destruido por la aplicación. Un cliente puede crear muchos objetos connection,
permitiendo conectarse a varios servidores de aplicaciones. Se recomienda que el objeto
connection sea declarado como una variable global para que sea usado similarmente como la
variable SQLCA.
// declare el objeto
connection g_connect
este es un ejemplo de un script de un cliente que se debería conectar a un servidor Jaguar con la
dirección IP de 120.122.20.21 y un listener IIOP configurado para usar el Puerto 9000.
//crear el objeto
g_connect = CREATE connection
//asignación de atributos
g_connection.driver = “Jaguar”
g_connection.location = “120.122.20.21:9000”
//conectarse
g_connection.ConnectToServer()
//proceso de Error
IF g_connect.ErrCode <> 0 THEN
//Error handling
END IF
Si el servidor no escucha o cualquiera de los valores de la propiedad son incorrectos, la

comunicación entre el cliente y el servidor no será posible.
_____________________________________________________________________________________________
Esto es implícito, el ejemplo muestra valores del objeto connection con código duro en el script
en lugar de código variable como el de un archivo INI o el register del sistema. Las buenas
técnicas de programación no se basan en código en duro, porque esto obligaría a que se esté
haciendo el despliegue (deploy) o actualizando constantemente la aplicación.
Usando el Connection Wizard
El ambiente de desarrollo de PowerBuilder está basado en wizards para hacer más fácil el
desarrollo de aplicaciones. Uno de los wizards es el Wizard connection object, que debe generar
un objeto custom connection automáticamente. El wizard del connection object puede ser
accedido desde la ventana de diálogo del tab PB Object como se muestra en la figura 4.39,
previamente tenemos que presionar el icono New del PowerBar, este objeto será creado en el
target Operaciones.pbt.
Figura 4.39
El wizard del objeto connection
Después de seleccionar el wizard del objeto connection, la siguiente ventana de diálogo debe
mostrarte un resumen de lo que permite crear con el wizard y la siguiente ventana que se
muestra en la figura 4.40 debe pedirte en que librería se guardará el objeto connection que se va
a crear.
Figura 4.40
Seleccionando el PBL
El diálogo de conectividad determinará donde el wizard generará un objeto connection o un

objeto transaction. En orden para generar un objeto connection, seleccione la opción “Requires
EAServer connection” como se muestra en la figura 4.41.
_____________________________________________________________________________________________
Figura 4.41
Seleccionando el EAServer connection
La información para el servidor Jaguar de la aplicación cliente que deberá conectarse es

definida en la ventana de diálogo del EAServer profile (vea la figura 4.42). Esta información es
usada para generar las funciones de inicialización del objeto connection.
Figura 4.42
Seleccionando el profile del servidor
El siguiente diálogo sugiere el nombre del package por defecto, como se muestra en la figura
4.43. Esta información es usado para llenar las propiedades de la aplicación del objeto
connection. Especificando un package por defecto, el componente EAServer puede ser creado
sin especificar esta información.
Figura 4.43
Especificando el package por defecto
_____________________________________________________________________________________________
La ventana de diálogo mostrada en la figura 4.44 requiere el nombre del objeto connection,
nosotros vamos a asignarle el nombre de n_operaciones_connect.
Figura 4.44
Nombrando el objeto connection
En la siguiente ventana de diálogo mostrada en las figuras 4.45 y 4.46 se debe determinar la
información de conexión que debe ser almacenada y recuperada en tiempo de ejecución. Las
opciones son guardadas en un archivo INI, el Registry, y codificadas en duro en el script..
Después de seleccionar la opción del archivo INI, el nombre del archivo INI es requerido. El
wizard genera el archivo INI.
Figura 4.45
Especificando los orígenes de la conectividad
_____________________________________________________________________________________________
Figura 4.46
Nombrando el archivo INI
Después de ingresar el nombre del archivo INI, se finaliza el ingreso de información como se
muestra en la última pantalla del wizard del objeto connection (vea la figura 4.47). Esta ventana
de diálogo congrega toda la información especificada en las ventanas de diálogo previas. Hacer
click en el botón finish para generar el objeto connection.
Figura 4.47
Finalizando el objeto connection
Usando el objeto connection generado
_____________________________________________________________________________________________
El objeto Connection generado tiene muchas variables de instancias que son usadas para
determinar la información que se usa para conectarse al servidor Jaguar, para esto debe de
presionar el tab “Declare Instance Varialbes”, estos se muestran a continuación:
String is_connectfrom = “1”

CONSTANT string IS_USE_INIFILE = “1”
CONSTANT string IS_USE_REGISTRY = “2”
CONSTANT string IS_USE_SCRIPT = “3”
La función of_getconnectioninfo usa la variable de instancia is_connectfrom para determinar

como se obtiene información del servidor Jaguar para conectarse. El connection wizard
automáticamente genera esta función. La función of_GetConecctionInfo acepta 5 argumentos
por referencia. Estos son usados para llenar las propiedades del objeto connection, la función se
muestra abajo :
//*-----------------------------------------------------------------*/
//* of_GetConnectionInfo: Get the stored connection information
//*
//* Note:
//* The source of connection information can be changed by
//* altering the value of the 'is_connectfrom' variable.
//*-----------------------------------------------------------------*/
Choose Case is_connectfrom
Case IS_USE_INIFILE /* Populate EAServer Connection from INI file */

string ls_inifile = "E:\techera\libro\aplicacion\operaciones.ini"
as_logid = ProfileString ( ls_inifile, "EAServer", "UserID", "jagadmin")

as_password = ProfileString ( ls_inifile, "EAServer", "PassWord", "")
as_server = ProfileString ( ls_inifile, "EAServer", "Server", "localhost")
as_port = ProfileString ( ls_inifile, "EAServer", "Port", "9000")
as_appl = ProfileString ( ls_inifile, "EAServer", "Application", "")
Case IS_USE_REGISTRY /* Populate EAServer Connection from Registry */

string ls_registrykey = "" + "\EAServer"
If RegistryGet ( ls_registrykey, "UserID", RegString!, as_logid ) <> 1 Then

RegistrySet ( ls_registrykey, "UserID", RegString!, "jagadmin" )
RegistryGet ( ls_registrykey, "UserID",RegString!, as_logid )
End If
If RegistryGet ( ls_registrykey, "PassWord",RegString!, as_password ) <> 1 Then
RegistrySet ( ls_registrykey, "PassWord", RegString!, "" )
RegistryGet ( ls_registrykey, "PassWord", RegString!, as_password )
End If
If RegistryGet ( ls_registrykey, "Server", RegString!, as_server ) <> 1 Then
RegistrySet ( ls_registrykey, "Server", RegString!, "localhost" )
RegistryGet ( ls_registrykey, "Server", RegString!, as_server )
End If
If RegistryGet ( ls_registrykey, "Port", RegString!, as_port ) <> 1 Then
RegistrySet ( ls_registrykey, "Port", RegString!, "9000" )
RegistryGet ( ls_registrykey, "Port", RegString!, as_port )
End If
If RegistryGet ( ls_registrykey, "Application", RegString!, as_appl ) <> 1 Then
RegistrySet ( ls_registrykey, "Application", RegString!, "" )
RegistryGet ( ls_registrykey, "Application", RegString!, as_appl )
_____________________________________________________________________________________________
End If
Case IS_USE_SCRIPT /* Populate EAServer Connection from Script */

as_logid = "jagadmin"
as_password = ""
as_server = "localhost"
as_port = "9000"
as_appl = ""
Case Else
Return -1
End Choose
Return 1
La función of_GetConnectionInfo es llamada en el evento constructor del objeto connection. El

wizard genera el código para el evento constructor. Se usa la información pasada a través de la
función, of_GetconnectionInfo, para inicializar las propiedades del objeto connection. El script
del evento es mostrado acontinuación:
//* Información de conexión es obtenida desde de:

//* - un archivo INI
//* - del Windows Registry
//* - del Script
//*
//* El origen de la información de la conexión puede ser cambiada
//* alterando losvalores de la variable 'is_connectfrom'.
//*--------------------------------------------------------*/
string ls_server, ls_port, ls_logid, ls_password, ls_appl
If of_GetConnectionInfo ( ls_server, ls_port, ls_logid, ls_password, ls_appl ) = 1 Then

this.Application = ls_appl
this.Driver = "jaguar"
this.UserID = ls_logid
this.Password = ls_password
this.Location = "iiop://" + ls_server + ":" + ls_port
End If
En el wizard, las opciones del archivo INI fueron especificados. El archivo INI es generado con la
siguiente información, que proviene del diálogo del servidor (vea la figura 4.46) :
[Jaguar]
UserID = jagadmin
Password =
Server = 120.122.20.21
Port = 9000
Application = JaguarHello
La aplicación cliente que usa el objeto connection generado por el wizard debe usar la función
ConnectToServer para conectarse al servidor Jaguar. Un ejemplo del script usando el objeto
connection generado se muestra a continuación :
//Ejemplo
n_operaciones_connect in_connect
in_connect = CREATE n_operaciones_connect
_____________________________________________________________________________________________
IF in_connect.ConnectToServer() <> 0 THEN

Messagebox(“Error”, in_connect.ErrText)
END IF
El evento Error del objeto Connection
El manejo de errores debido a problemas con las aplicaciones distribuidas o a procesos

defectuosos en los componentes es manejado por el evento Error del objeto connection.
Después que un error es detectado, el evento Error del objeto connection es disparado. Si el
evento Error no tiene código o el argumento de acción es configurado a ExceptionFail!, el evento
Error del sistema del objeto application es disparado. Si el evento Error del sistema no tiene
código, un error de aplicación es generado y la aplicación es terminada. Esto es importante para
capturar los errores y prevenir que la aplicación cliente sea forzada a terminar. El evento error
del objeto Connection tiene muchos argumentos para ayudarte a verificar el tipo de error. La
tabla 4.6 te muestra los argumentos disponibles en el evento Error.
Tabla 4.6 argumentos disponibles en el evento Error
Argumento Tipo Descripción

ErrorNumber Unsignedinteger Genera el número de error
ErrorText String Texto de la descripción del error
ErrorObject String El objeto donde el error ha ocurrido
ErrorScript String El script donde el error ha ocurrido
ErrorLine Unsignedinteger El número de línea del script donde el error ha
ocurrido.
Action ExceptionAction Un valor enumerado que determina que acción tomar
basado en el error
Returnvalue Any El errorNumber por defecto, que puede ser modificado
para devolver algo.
El tipo de dato enumerado ExceptionAction acepta cuatro diferentes valores.
• ExceptionFail!
• ExceptionRetry!
• ExceptionIgnore!
• ExceptionSubstituteReturnValue!
La acción ExceptionRetry! Deberá reenviar el requerimiento de falla. la acción ExceptionIgnore!

deberá ignorar el error como sino hubiera sucedido. Dependiendo del error, esto puede traer
mayores problemas y eventualmente afectar a la aplicación. La acción ExceptionFail! debe
causar que el evento Error del sistema del objeto application sea disparado. La acción
ExceptionSubstituteReturnValue! Deberá permitir retornar un código de error diferente.
En el siguiente ejemplo, el evento error prepara un mensaje que reporta una condición de error y
permite a los usuarios manejar lo que sucederá en lo siguiente, basado en la respuesta del
mensaje. Este código también revisa una variable booleana, ib_show_msg, que es una variable
de instancia adicionada en el objeto custom class para determinar si el mensaje mostrado es
apropiado. En algunos casos, el objeto connection puede ser usado por un componente
EAServer que puede acceder a otro componente EAServer en otro servidor Jaguar. La función
Messagebox no debería ser usada para mostrar el error cuando el objeto connection es usado
por un componente EAServer.
_____________________________________________________________________________________________
//El evento error le permite responder para comunicar el error en el cliente componente de //una
aplicación distribuida.
Integer li_choice
String ls_msg
Ls_msg = “Código de error (”+string(ErrorNumber) + “) ”+ErrorText
IF ib_show_msg THEN
Il_choice = messagebox(“Error de Conexión”,ls_msg,Question!,AbortRetryIgnore!)
CHOOSE CASE li_choice

CASE 1
Action = ExceptionFail!
CASE 2
Action = ExceptionRetry!
CASE 3
Action = ExceptionIgnore!
END CHOOSE
ELSE
END IF
Otro ejemplo del evento error es proporcionar un manejo especial basado en el código de error.
//el evento error
integer li_result
string ls_msg
Ls_msg = “Código de error (”+string(ErrorNumber) + “) ”+ErrorText
CHOOSE CASE ErrorNumber

CASE 75,87
//Pérdida de conexión
//attempt to reconnect
li_result = g_JagConnect.ConnectToServer()
IF li_result = 0 THEN
Action = ExceptionIgnore!
ELSE
Messagebox(“Error”,”La conexión al servidor fue perdida ”)
END IF
CASE ELSE
Messagebox(“Error”,ls_msg)
END CHOOSE
Desde que los errores necesitan ser rastreados y arreglados rápidamente como sea posible, se
debe adicionar lógica para escribir la información o enviar un email al administrador del servidor.
Los código de error del objeto Connection
La Tabla 4.7 Muestra los códigos de errores encontrados cuando se usa el objeto connection.
_____________________________________________________________________________________________
Tabla 4.7 el código de error retornado por las funciones de conexión
Código de error Descripción

0 Satisfactorio
50 Error del servicio distribuido
52 Error de comunicación distribuida
53 El servidor requerido no está activo
54 El servidor no está aceptando requerimientos
55 El requerimiento fue terminado anormalmente
56 La respuesta del requerimiento es incompleta
57 No está conectado
58 La instancia del objeto no existe
62 El servidor está ocupado
92 La propiedad requerida se ha perdido o es invalida
Generando el EAServer proxy
Los objetos proxy son conocidos como stubs en la terminología CORBA. Los EAServer proxy
son una parte muy importante de la aplicación cliente. Estos objetos te proveen de una manera
para compilar satisfactoriamente las referencias a los componentes EAServer en el script. En
tiempo de ejecución te proveen un rol muy importante, representando el objeto remoto en el
cliente y empaquetando los datos para que puedan ser enviados a través de la red. El proxy
también contiene el ORB del lado del cliente que es requerido para la comunicación con el
servidor Jaguar. La interfaz de la aplicación cliente es mostrada en la figura 4.48.
Figura 4.48
La Aplicación cliente de las Operaciones
Para generar un proxy, el componente debe ser desplegado en el servidor Jaguar. Este es el
caso del ejemplo de las Operaciones. Una alternativa es crear la definición de un componente o
módulo en el servidor Jaguar hasta que el objeto fuera desarrollado. Definiendo al componente
en el Jaguar Manager antes de que sea construido permite a la aplicación del cliente y al
desarrollador del componente tomar un lugar simultáneamente.
El proxy es creado desde el CORBA IDL que es generado y almacenado en el Repositorio del
EAServer cuando el componente es desplegado en el servidor o definido usando la
reconstrucción a menos que la interfaz del componente sea cambiado. Esto es una de las
mayores fuerzas de la arquitectura distribuida, la habilidad de cambiar los procesos del lado del
servidor sin hacer el redespliegue de la aplicación cliente.
Para construir el objeto proxy de un componente EAServer, abrir la ventana de diálogo de la

opción New. Seleccionar el tab Project y click en el icono EAServer Proxy Wizard como se
muestra en la figura 4.49.
Figura 4.49
El wizard del EAServer Proxy project
_____________________________________________________________________________________________
Esto inicializa el EAServer Proxy Wizard. La primera ventana de diálogo te pide la ubicación de
la PBL donde va a ser almacenado el objeto project (ver la figura 4.50). la siguiente ventana de
diálogo, mostrada en la figura 4.51, te debe pedir el nombre del objeto project, vamos a ingresar
el nombre de p_proxy_operaciones. Los objetos projects Proxys pueden generar los proxys para
los componentes de diferentes packages. Sin embargo, se puede asignar a cada objeto project
un solo package porque el componente EAServer no puede ser desplegado a más de un
package.
Figura 4.50
Librería destino
Figura 4.51
Nombre del Project
Especifique la información del servidor en la ventana de diálogo ilustrada en la figura 4.52

indique la información de conexión requerida para conectarse al servidor Jaguar donde el
_____________________________________________________________________________________________
componente fue desplegado. Para que PowerBuilder se conecte al servidor Jaguar, cuando las
máquinas de desarrollo no están en la misma máquina del servidor Jaguar, el Jaguar debe tener
un listener IIOP configurado con otro nombre diferente al de localhost. Las máquinas remotas no
pueden acceder al servidor Jaguar sin cambiar el nombre del listener por defecto (actualmente el
Listener viene configurado con el nombre de la máquina). Todos estos datos son definidos en el
profile de EAServer.
Figura 4.52
Ventana de información del Server
El siguiente paso es seleccionar los componentes para los proxys que van a ser generados.
Haciendo click en los ckeckboxes como se muestra en la figura 4.53 se puede especificar
componentes individuales o un package entero. Los packages son la primera categoría de la lista
de jerarquía, y son indicados por un icono de color verde. Expandiendo el árbol cada package
expondrá todos los componentes que están asignados. Haciendo click en el checkbox del nivel
del package indica que generará un proxy para todos los componentes. Los componentes
también pueden ser seleccionados individualmente haciendo click en el checkbox de cada
componente.
Figura 4.53
Packages y componentes
Una vez que los componentes son seleccionados, el wizard te pedirá la ruta de la librería donde
los proxys serán generados (figura 4.54). el PBL puede ser uno existente, o uno nuevo que el
wizard puede generar. Cuando el nuevo PBL para el proxy es creado por el wizard, recuerde
adicionarlo en la lista del target de la aplicación cliente cuando el wizard ha finalizado. Usando
una PBL separada habilita a los objetos proxy para que puedan ser compartidas en diferentes
aplicaciones, sin ser regeneradas.
_____________________________________________________________________________________________
Figura 4.54
Librería del objeto Proxy
La penúltima ventana de diálogo, antes de finalizar el wizard específica las opciones de creación,
la ventana de diálogo del Build Options es mostrada en la figura 4.55.
Figura 4.55
El Build options
La opción clear deployment PBL debe remover todos los objetos de la librería especificada,
Todos los objetos proxy deben ser almacenados en el PBL.
Cada proxy que es generado tiene el mismo nombre del componente. Por ejemplo
n_operaciones debe tener un proxy generado para este como el nombre de n_operaciones, la
opción “The Prepend Jaguar package name to component name” debe generar un proxy donde
el nombre del package del jaguar es el prefijo para el nombre del componente. Cuando esta
opción es habilitada, el proxy generado para el n_operaciones en el package Operaciones
deberá ser nombrado en un package existente para los proxys generados sin sobrescribirlos
cada vez.
Después de finalizar la ventana de diálogo de Build Options, el wizard deberá mostrar toda la
información especificada en las ventanas de diálogos previas. Para generar el objeto project,
click en el botón finish (ver la figura 4.56).
Figura 4.56
Creando el EAServer proxy project
_____________________________________________________________________________________________
Una vez que el objeto project fue creado, los objetos proxy deben ser generados. El wizard solo
crea el objeto project, no los objetos proxy, para generar los objeto proxy es muy fácil. Abrir
nuevamente el objeto project creado en el painter del project y seleccionar la opción “Deploy”
El objeto project debe conectarse al servidor Jaguar especificado y generar los proxys para todos
los componentes que fueron seleccionados. Los objetos proxy son ubicados en el PBL definido
en el objeto project. Cualquiera de las opciones especificadas en el wizard pueden ser
cambiadas en el painter del objeto project.
Figura 4.57
Creando el EAServer proxy
La aplicación cliente de las Operaciones
Una vez que los objetos proxy y el objeto connection fueron creados, ahora se está listo para
crear el objeto window de la aplicación cliente. La aplicación cliente de las Operaciones debe ser
un Single Document Interfaz (SDI). El objeto window w_operaciones debe ser definido como de
tipo main, y debe tener las mismas caraterísticas como se muestra en la figura 4.58. Los dos
objetivos principales de esta aplicación son el conectarse al servidor Jaguar y acceder al
componente EAServer.
_____________________________________________________________________________________________
Figura 4.58
La aplicación cliente de las Operaciones.
Para crear la aplicación, se necesita declarar dos variables de instancia, una para el objeto
conecction y el otro para el objeto proxy, estas son definidicas en el objeto window
w_operaciones. El objeto custom connection creado puede ser usado en este ejemplo. La
declaración de cada variable es mostrada a continuación:
//variables de Instancia
n_connect in_connect
n_operaciones in_operaciones
Conectándose al EAServer
Para acceder a los componentes en el servidor Jaguar, la aplicación cliente primero debe
conectarse al servidor. El botón Conectarse del objeto window debe manejar esto para que el
usuario haga click. El código para el evento click del botón se muestra a continuación :
//***
integer li_valor
in_connect = create n_operaciones_connect

li_valor = in_connect.ConnectToServer()
IF li_valor <> 0 THEN

Messagebox("ERROR","No se pudo conectar al servidor "+in_connect.ErrText)
ELSE
Messagebox("OK","Se conectó al servidor “)
END IF
El botón Conectarse maneja la inicialización del objeto conecction. El mensaje de satisfactorio o

falla es mostrada a través de la función Messagebox.
Accesando al componente EAServer
Para acceder al componente en el servidor Jaguar, la aplicación cliente necesita instanciar el

componente e invocar los métodos. Para instanciar el componente EAServer, la función
CreateInstance del objeto connection es usado. Una vez que el componente es instanciado, la
aplicación cliente puede invocar los métodos del componente como cualquier objeto no visual de
PowerBuilder.
Creando el componente EAServer
Cuando la función CreateInstance es llamado, permite el acceso a una instancia del componente
del servidor Jaguar, el objeto proxy es creado en el cliente. El objeto connection debe conectarse
_____________________________________________________________________________________________
al servidor usando la función ConnectToServer antes de usar la función CreateInstance. La

función CreateInstance retorna 0 si es satisfactorio. Si existe un error, el código de error
distribuido es retornado y activa el evento Error.
La sintaxis para la función CreateInstance :
Connection.CreateInstance (objectvariable {,classename})
El argumento objectvariable es la variable cuyo tipo de dato es el tipo de la clase del proxy del
objeto creado inicializado en el servidor. Esto también puede ser el nombre de la clase del proxy
de un objeto ancestro del objeto clase que es creado en el servidor.
El argumento classname es valor string del nombre de la clase del tipo de dato que es creado en
el servidor. Cuando se accede a un componente EAServer, esto también puede ser usado para
especificar el nombre del package. La sintaxis para especificar un componente y un package es
separar el nombre del componente del nombre del package con un “/”. Un ejemplo se muestra a
continuación :
n_operaciones in_operaciones
string ls_class
ls_class = “n_operaciones/operaciones”
gn_connect.CreateInstance(in_operaciones,ls_class)
Invocando métodos en un componente EAServer
Una vez creado el objeto, la ubicación física es transparente para el script del lado del cliente
que usa el objeto. Los métodos pueden ser invocados usando la notación del punto. Por ejemplo
para llamar al método of_calculo en un componente EAServer después de este ser instanciado,
use el siguiente código :
in_operaciones.of_calculo()
El botón Procesar en la ventana instancia al componente EAServer n_operaciones, y llama al

método of_calculo. El código para el botón es listado abajo :
//evento clicked : botón Procesar

integer li_total
integer li_valor1
integer li_valor2
string ls_operador
li_valor1 = integer(sle_1.text)
li_valor2 = integer(sle_2.text)
ls_operador = ddlb_1.text
//Crea el objeto proxy

IF in_connect.CreateInstance(in_operaciones) = 0 THEN
li_total = in_operaciones.of_calculo(li_valor1,li_valor2,ls_operador)
ELSE
//Error
messagebox("ERROR","No se pudo crear la instancia del objeto "+ &
string(in_connect.Errcode) + " :"+in_connect.ErrText)
END IF
_____________________________________________________________________________________________
sle_3.Text = string(li_total)
NOTA: Si el componente no puede ser encontrado en el package especificado o un package no

está definido, la función CreateInstance debe retornar el código 50 y el mensaje de error :
Distributed Service Error : E13 Could not create object of class “n_operaciones”
Ejecutando la aplicación
Una vez que se ha creado y configurado todos los objetos, lo siguiente es agregar en el evento
Open del objeto application “operaciones” el siguiente código, para abrir la ventana
w_operaciones:
Open (w_operaciones)
Ejecutar la aplicación desde el ambiente PowerBuilder. Click en el botón Conectarse. La

aplicación debe de informar si fue satisfactorio o hubo una falla. Si la aplicación se conectó
satisfactoriamente, la ventana debe aparecer como se muestra en la figura 4.59.
Figura 4.59
Ejecutando la aplicación Operaciones
Después de conectarse al servidor Jaguar, ingresar valores en los campos y presionar el botón
Procesar. La ventana debe de procesar la operación seleccionada con los valores ingresados
Figura 4.60
Ejecutando la aplicación Operaciones
Nota: Si se ha seguido los pasos indicados en este libro, no tendrá problemas pero normalmente
ocurren ciertos problemas, como el de conexión o el de creación de Instancias, asegúrese de
que el servicio del servidor Jaguar esté activo y que las referencias a los objetos sean las
indicadas.
Destruyendo el EAServer proxy
Después que la ventana es cerrada, el objeto EAServer proxy es destruido. Esto siempre es una
buena idea para liberar al EAServer proxy cuando la aplicación cliente es finalizado usando el
_____________________________________________________________________________________________
componente EAServer. Un EAServer proxy puede ser explícitamente destruido usando la

sentencia DESTROY.
DESTROY in_operaciones
La destrucción del objeto proxy en el cliente no destruye la instancia del componente en el

servidor. EAServer siempre maneja la destrucción del componente del servidor. Esto es
detallado en el ciclo de vida los componentes en el capítulo 5.
Resumen
Desde la versión 8 hasta la versión 9 PowerBuilder ha sido totalmente integrada con el

EAServer, permitiendo esto a los desarrolladores poder crear sus aplicaciones distribuidas con el
menor tiempo, por las facilidades de la programación Drag and Drop, desde el System Tree uno
puede tener un mejor control para generar los componentes y manipularlos. Además te brinda
una variedad de Wizard que te permiten crear estos objetos con el menor tiempo. El lector podrá
ver que el gran tiempo invertido en manejar esta herramienta es mejorada con estas nuevas
versiones para el desarrollo de aplicaciones distribuidas.
_____________________________________________________________________________________________

04creación de Componentes PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

04creación de Componentes PDF

Cargado por

Copyright:

Formatos disponibles

Componentes con PowerBuilder | 1

Desarrollando componentes EAServer con PowerBuilder

En este capítulo vamos a tratar acerca de la creación de los componentes EAServer en

• Construyendo un componente EAServer en PowerBuilder

Desarrollar aplicaciones para el EAServer, o cualquier otro servidor de aplicaciones, requiere

El desarrollo de EAServer está enfocado en los componentes. Pueden componerse de uno o

Los componentes en PowerBuilder

EAServer soporta diferentes modelos de componentes, incluyendo PowerBuilder. El modelo de

Creando los Componentes EAServer

Una vez escogido la opción Workspace se ingresa el nombre de techera4.pbw en la ruta

Creando un profile de EAServer

Verificando los componentes del EAServer

El wizard del componente EAServer

Se puede crear un nuevo componente implementándolo con la interfaz existente de un

En el prompt de la ventana de diálogo Specify New Component se debe de ingresar un nombre y

Cuando se define un componente EAServer se debe de haber definido previamente el profile de

En la siguiente ventana se debe de especificar el tipo de componente, le vamos a indicar que

La opción Transaction support determina si un componente deberá usar el Jaguar Transaction

En el nombre del project vamos a indicarle p_operaciones_servidor, tal como se muestra en la

El wizard del componente EAServer debe de crear el Target operaciones_servidor.pbt, la librería

• Objeto application (operaciones_servidor)

Programar el objeto Operaciones

Ahora vamos a programar el objeto n_operaciones, el ejemplo de las Operaciones deberá

La aplicación cliente deberá conectarse al EAServer e invocar al componente de n_operaciones

El wizard ha creado el objeto project para hacer deploy al componente EAServer.

Paso de valor Tipo argumento Nombre de argumento

En el editor del script adicione el siguiente código :

CHOOSE CASE as_operador

Haciendo deploy al objeto EAServer

Si se habilitado la opción del live-editing, el objeto EAServer ya ha sido instalado en el servidor

Aplicaciones cliente PowerBuilder

Construyendo un cliente EAServer en PowerBuilder

• Construir un objeto connection

• Hacer deploy del cliente

El cliente se va a comunicar con el servidor mediante el objeto Connection. En este objeto se

Propiedades del objeto Connection

El User ID, pasword, y el connectstring

Las propiedades del EAServer connection

Tabla 4.1 Propiedades de conexión relacionadas con el EAServer

Funciones y Eventos del objeto Connection

El objeto connection tiene muchas funciones. Algunos se relacionan con el Distributed

Tabla 4.3 Funciones del objeto connection usados por PowerBuilder

Estos son los pasos para que un cliente se conecte al Jaguar:

Si el servidor no escucha o cualquiera de los valores de la propiedad son incorrectos, la

Usando el Connection Wizard

El diálogo de conectividad determinará donde el wizard generará un objeto connection o un

La información para el servidor Jaguar de la aplicación cliente que deberá conectarse es

Usando el objeto connection generado

String is_connectfrom = “1”

La función of_getconnectioninfo usa la variable de instancia is_connectfrom para determinar

Case IS_USE_INIFILE /* Populate EAServer Connection from INI file */

as_logid = ProfileString ( ls_inifile, "EAServer", "UserID", "jagadmin")

Case IS_USE_REGISTRY /* Populate EAServer Connection from Registry */

If RegistryGet ( ls_registrykey, "UserID", RegString!, as_logid ) <> 1 Then

Case IS_USE_SCRIPT /* Populate EAServer Connection from Script */

La función of_GetConnectionInfo es llamada en el evento constructor del objeto connection. El

//* Información de conexión es obtenida desde de:

If of_GetConnectionInfo ( ls_server, ls_port, ls_logid, ls_password, ls_appl ) = 1 Then

IF in_connect.ConnectToServer() <> 0 THEN

El evento Error del objeto Connection

El manejo de errores debido a problemas con las aplicaciones distribuidas o a procesos

Tabla 4.6 argumentos disponibles en el evento Error

Argumento Tipo Descripción