PB Distribuido Manual v2016 PDF

Facultad de Ingeniería
EAP Ingeniería de Sistemas e Informática
Creación de Aplicaciones Distribuidas con

PowerBuilder y EAServer
Versión 2016
Primera Parte - Arquitectura Distribuida
Autor:
Ing. Camilo Ernesto Suárez Rebaza
Docente UNS
Dpto. Acad. Ing. Civil y Sistemas
Universidad Nacional del Santa Desarrollo de Aplicaciones Distribuidas
Departamento Académico de Civil y Sistemas con PowerBuilder 12.5 y EAServer 6.0.2
Contenido
I. Creación y Programación de Base de Datos ............................................................. 3
1.1. Descripción del Caso de Estudio ....................................................................... 3
1.2. Creación de la Base de Datos ............................................................................ 4
1.3. Creación del Servicio ....................................................................................... 14
1.4. Creación de Tablas, Relaciones e índices. ....................................................... 19
1.5. Creación de Funciones y Procedimientos Almacenados. ................................ 31
1.6. Creación de Triggers. ....................................................................................... 37
II. Framework GUI - Cliente .................................................................................... 45
2.1. Creación del Workspace .................................................................................. 45
2.2. Fuentes de datos y DataWindow para ingreso de datos. .................................. 49
2.3. Mantenimiento con Procedimientos Almacenados .......................................... 57
2.4. Ventanas para Ingreso de Datos. ...................................................................... 59
2.5. Ventana MDI y Menú principal. ...................................................................... 62
2.6. Gestión de Reportes. ........................................................................................ 63
III. Arquitectura Distribuida y EAServer .................................................................. 64
3.1. Desarrollo de Aplicaciones n-Tier con PowerBuilder ..................................... 64
3.2. Creación de Servidores EAServer ................................................................... 64
3.3. Creación de Packages ...................................................................................... 75
3.4. Creación de Caché de Conexiones................................................................... 79
3.5. Perfiles de conexión a EAServer en PowerBuilder IDE .................................. 85
3.6. Definir Componente ........................................................................................ 88
IV. Ciclo de vida y Creación de Componentes ........................................................ 101
4.1. Modelo del Ciclo de Vida de los Componentes EAServer. ........................... 101
4.2. Creación de los Objetos No Visuales de la Aplicación. ................................ 102
4.3. Configuración de Componentes EAServer. ................................................... 108
4.4. Creación de Objetos Proxy. ........................................................................... 110
4.5. FrameWork GUI con Componentes ............................................................. 117
Ms. Ing. Camilo E. Suárez Rebaza 2

Manual del Estudiante. Versión 2016
I. Creación y Programación de Base de Datos
1.1. Descripción del Caso de Estudio

El caso de estudio del presente curso trata de una Empresa dedicada a la
comercialización de computadoras compatibles y sus repuestos.
Cotizar Productos
Confirmar Cotización Emitir Guia de Remisión
Vendedor Reportar Pendientes
Registrar Compra
Almacenero
Registrar Proveedor
Registrar Producto Emitir Comprobante
Pedir Productos
Reportar Ingresos Cajero

Administrador Registrar Vendedores
Registrar Transportista
El Caso de Estudio tiene las siguientes restricciones:

 Sólo se venden cajas blancas, es decir no se vender computadoras de marca.
 Los Servicios de Mantenimiento y reparaciones no están contemplados.
 La gestión de personal (capacitaciones y planilla) escapa al modelo
 Los pagos son al contado.
 La aplicación sólo emitirá Boletas o facturas como comprobantes de pago.

1.2. Creación de la Base de Datos

Como Motor de Base de Datos utilizaremos SQL Anywhere Studio 9.0 Developer
Edition.
EL modelo Entidad – Relación es el siguiente:
Transportista
ID_Transportista smallint <pk>
Vendedor RUC varchar(12)
Razon varchar(80)
ID_Vendedor smallint <pk> Telefono varchar(15)
Apellidos varchar(40)
Nombres varchar(50) Cotizacion
Direccion varchar(100) ID_Cotizacion bigint <pk> Cliente
F_Ingreso date ID_Cliente bigint <fk1> GuiaSalida
ID_Cliente bigint <pk>
Estado smallint ID_Vendedor smallint <fk2>
Apellidos varchar(40) ID_GuiaSalida bigint <pk>
Fecha date
Nombres varchar(50) ID_Transportista smallint <fk1>
F_Vencimiento date
Direccion varchar(100) ID_Boleta bigint <fk2>
Proveedor
e_mail varchar(30) ID_Factura bigint <fk3>
RUC char(12) <pk> telefono varchar(15)
Razon varchar(100)
Direccion varchar(100)
Telefono varchar(15)
Cotizacion_Detalle
ID_Cotizacion bigint <pk,fk1> Boleta
ID_Producto bigint <pk,fk2> ID_Boleta bigint <pk>
Cantidad smallint Factura
ID_Cliente bigint <fk>
Compras
Precio money Fecha date ID_Factura bigint <pk>
ID_Compra bigint <pk> Total money ID_Cliente bigint <fk>
ID_Producto bigint <fk2> Estado smallint Fecha date
RUC char(12) <fk1> Total money
NroGuia varchar(20) Estado smallint
Cantidad smallint
PrecioUnit money
Boleta_Detalle
Producto ID_Boleta bigint <pk,fk1>
ID_Producto bigint <pk> ID_Producto bigint <pk,fk2>
Cantidad smallint Factura_Detalle
Categoria ID_Categoria smallint <fk>
Descripcion varchar(100) Precio money ID_Factura bigint <pk,fk1>
ID_Categoria smallint <pk> SubTotal money
StockActual integer ID_Producto bigint <pk,fk2>
Descripcion varchar(100)
StockMinimo integer Cantidad smallint
PrecioActual money Precio money
Comentarios varchar(500) SubTotal money
Antes de crear las tablas y demás objetos, debemos crear la Base de Datos, esta
tarea la realizamos con Sybase Central (consola de administración):

En la interface de Sybase Central hacemos <Doble Clic> sobre

En el menú <Tools> seleccionamos <Create Database>:
Ejecutamos dicha herramienta y obtenemos:

Clic en <siguiente>:
Clic en <siguiente> y escribimos la localización de la Base de Datos:

Clic en <Siguiente>:
Clic en siguiente:


Clic en siguiente:
Clic en siguiente:

Escogemos UTF8 y clic en <siguiente>:
Escogemos UTF8 para datos tipo NChar y clic en <Siguiente>:

Establecemos que se ignoren los espacios en blanco en las comparaciones:
Establecemos la clave para el usuario “DBA” a “SQL” y clic en <Siguiente>:

Desmarcamos que se conecte a la base de datos y clic en <Siguiente>
Clic en <Finalizar> y Listo:

1.3. Creación del Servicio

Luego que hemos creado la Base de datos debemos levantarla como servicio para
que ésta se encuentre disponible en cualquier momento con solo iniciar la
computadora o máquina virtual que funcione como servidor de datos.
Para crear el servicio iniciamos la Herramienta Sybase Central y seleccionamos

la ficha <Services>, hacemos clic con el botón secundario y nos aparecerá un
menú emergente tal como se muestra a continuación:
Dar clic en <Service…> y escribimos “ServerData” para el nombre del servicio:

Se escoge el Motor de base de datos en Red y clic en <Siguiente>:

Se especifica el ejecutable para Red y clic en <Siguiente>:


Clic en <Finalizar> finalmente iniciamos el servicio <botón derecho>:

1.4. Creación de Tablas, Relaciones e índices.

Para crear las tablas primero debemos conectar a la Base de datos desde Sybase
Central, haciendo <clic derecho> en la opción SQL Anywhere 12 que se
encuentra en el árbol derecho:
Clic en <Connect…> y digitamos “dba” y “Sql”:

Luego como vamos a conectarnos a una base de datos que está siendo
administrada por el servidor de datos en red (que está corriendo como un
servicio), debemos especificar los parámetros siguientes:
Parámetro Valor Explicación
Action Connect to a running Conectar a una base de datos cuyo

database on this servidor está en esta computadora
computer
Server ServerData Es el nombre del servidor de datos al
Name cual conectarse, que es especificado
por el parámetro –n a la hora de
configurar su inicio, en este caso
cuando se configuro el servicio.
Database VentaPC Como un servidor de datos puede
Name administrar varias base de datos, aquí
especificamos a cuál de ellas nos
vamos a conectar

Clic en <Conectar> y obtenemos lo siguiente:
Clic en el fólder Tables y luego <clic derecho> y aparece el siguiente menú:

Clic en <Table…> y damos el nombre de la tabla “Categoria”:


Clic en <Finalizar>, presentándonos la interface para el ingreso de los campos.

Ingresamos el campo ID_Categoria y seleccionamos su tipo de datos, valor por
defecto, si es clave primaria o no, etc:

Luego agregamos el campo <Descripción> y guardamos la tabla :
Lo mismo hacemos lo mismo para cada una de las demás tablas del modelo, por
ejemplo para la tabla “Producto”:
Cabe destacar que no creamos los campos <fk>, éstos se añaden a la tabla cuando
se crean las relaciones de clave foránea con otras tablas de acuerdo a nuestro
modelo entidad-relación. Cabe destacar que la base de datos puede ser generada
automáticamente usando una herramienta CASE, sin embargo y con fines
didácticos seguiremos la forma manual.
Para relacionar esta tabla con la tabla “Categoria”, hacemos clic en la pestaña
“Constraints”, luego hacemos <clic derecho> y aparece el siguiente menú:

Clic en <Foreign Key…>, Seleccionamos la tabla “padre”, y para el caso de esta

relación seleccionamos la tabla Categoría, obteniendo:

Especificamos el nombre “Categoria_Producto_FK”, luego clic en <Siguiente>:
Aquí nos indica que se va crear la columna “ID_Categoria”, Clic en <Siguiente>:

Seleccionamos “Cascade values” y Clic en <Siguiente>:


Nos presenta el siguiente resumen:
Clic en <Finalizar> y listo, el resultado final es el siguiente:
Lo mismo hacemos para todas las demás relaciones de la Base de Datos.

1.5. Creación de Funciones y Procedimientos Almacenados.

La idea es crear procedimientos almacenados para el ingreso de datos (nuevos
registros) y también para reportes complejos que demandan el procesamiento de
muchas tablas o tablas que contienen gran cantidad de registros.
Empezaremos creando procedimientos almacenados para el ingreso de nuevos

registros, tomando como ejemplo la creación del procedimiento almacenado que
nos permitirá agregar un nuevo registro en la tabla “Categoria” devolviendo la
Clave Primaria generada. Nos vamos a la carpeta “Procedures & Functions” y
<clic derecho>:
Clic en <Procedure…> y escribimos el nombre “sp_Categoria_Agregar”:


Clic en <Finalizar> y escribimos el código respectivo:
Guardamos y Listo. Los demás procedimientos almacenados se crean de

manera análoga, y el código para cada uno de ellos es el siguiente:

Para agregar Boleta:
Para agregar Cliente:
Para agregar Cotización:

Para agregar Factura:
Para agregar Producto:
Para agregar Proveedor:

Para agregar Transportista:
Para agregar Vendedor:

1.6. Creación de Triggers.

Los triggers son lógica de negocio asociada a eventos específicos de una tabla en
la Base de Datos. Existen 3 tipos de Eventos que ocurren sobre una tabla, que en
Terminos Orientados a Objetos se les conoce como primitivas de las clase tipo
entidad, y son de: Inserción, Actualización (General y Específica de algunos
campos) y Eliminación; los mismos que se disparan al insertar, actualizar o
eliminar cualquier fila en una tabla.
Para nuestro caso de estudio vamos a agregar 3 trigger a la tabla “Compras” cuya
finalidad es mantener actualizado el precio de venta actual y el stock de los
productos.
Seleccionamos la tabla “Compras” en el árbol de objetos y en el panel derecho

seleccionamos “Pestaña Trigger”, luego hacemos clic derecho y obtenemos:
Hacemos clic en <Trigger> y escribimos tI_Compras_ActualizarProducto:

Clic en <Siguiente> y marcamos <Insert>:
Clic en <Siguiente> y marcamos <After Event>

Clic en <Finalizar> y escribimos el siguiente código:
Luego guardamos y listo, el Trigger ha sido creado, ahora añadiremos otro:

Hacemos clic en <Nuevo…> y escribimos “tU_Compras_ActualizarProducto”:
Clic en <Siguiente> y marcamos <Actualización de columnas> (precio y

cantidad):

Clic en <Siguiente> y marcamos <después del evento>:
Clic en <Finalizar> y escribimos el siguiente código:

Guardamos y el Trigger es creado, ahora añadiremos uno para la eliminación:
Clic en <Trigger…> y escribimos “tD_Compras_ActualizarProducto”:
Clic en <Siguiente> y marcamos <Eliminar>:

Clic en <Siguiente> y marcamos “Después del Evento”:

Clic en <Finalizar>, escribimos el Siguiente código y por último guardamos:

II. Framework GUI - Cliente
2.1. Creación del Workspace

Para crear el workspace de trabajo hacemos clic en “Archivo” del menú principal
y seleccionamos “New”:

Clic en <OK>, seleccionamos una ruta y ponemos el nombre “VentaPC”:
Luego procedemos a agregar un target de aplicación:

Clic en <OK> y ponemos “app_venta_gui”, previamente creamos una carpeta

“GUI” y dentro de ella guardamos la aplicación:

Agregamos un archivo de librería, para almacenar los datawindows:
Clic en <OK> y le ponemos “app_venta_dwingreso”:

Clic en <Finish>:
2.2. Fuentes de datos y DataWindow para ingreso de datos.

Para crear un objeto DataWindow primero debemos crear una fuente de datos
(DSN) y luego un perfil de conexión para esa fuente de datos.
Entonces abrimos el administrador de Fuentes de Datos (Administrador ODBC)

Luego seleccionamos la pestaña DSN de Sistema y obtenemos:
Hacemos clic en agregar, y seleccionamos SQL Anywhere 12:
Clic en <Finalizar> y completamos tal como sigue:


Hacer clic en <Aceptar> para terminar de crear el DSN.
Ahora en el Entorno PowerBuilder vamos a crear un perfil da datos que conecte

con la fuente de datos VentaPC. Abrimos los Perfiles de Base de Datos:
Hacer clic en <New…>, establecemos el nombre del perfil =VentaPC, Data

Source = VentaPC, el usuario = dba y la Clave = sql, y obtenemos:

Hacemos clic en OK y finalmente, conectamos con la base de Datos.

Ahora procedemos a crear los DataWindows para el ingreso de datos:

Clic en <OK>:
Luego seleccionamos la tabla “Cliente”
Clic en <Abrir> y configuramos la consulta de la siguiente manera:

Luego configuramos la presentación del Datawindow:
Y guardamos con el nombre “d_cliente”.

En el menú <Rows / Update Properties> configuramos de esta manera:

2.3. Mantenimiento con Procedimientos Almacenados

El objetivo es enlazar los procedimientos almacenados ya creados con los
datawindows, para que cuando se inserte un nuevo registro en lugar de generarse
una consulta SQL de inserción se utilice el procedimiento almacenado creado para
tal fin.
Hacemos clic en el menú <Rows / Stored Procedure Update> y tenemos:
Clic en <Procedure…>, seleccionamos “sp_Cliente_Insertar”

Hacemos clic en <OK>:
Ahora a cada argumento del procedimiento almacenado lo relacionamos con un

campo del DataWindow:

Finalmente hacemos clic en <OK> y guardamos.

Lo mismo hacemos para las tablas: Categoría, Producto, Proveedor, transportista
y vendedor.
2.4. Ventanas para Ingreso de Datos.

Primero creamos una clase “w_padre” que servirá de base para todas las demás
ventanas de la aplicación:
De “w_Padre” heredamos “w_Class_Registrador”: y le agregamos los

siguientes controles:

A esta ventana le agregamos las siguientes funciones:
Y cuyo código se muestra a continuación:
wf_recuperar ()
// Nota: este código debe ser modificado al pasar a 3 capas
dw_Ingreso.Retrieve()
wf_Modo_Edicion(False)
long wf_nuevo ()
Long Pos
Pos = dw_Ingreso.InsertRow(0)
IF Pos > 0 THEN dw_Ingreso.ScrollToRow(Pos)
wf_Modo_Edicion(True)
Return Pos

wf_modo_edicion (boolean editar)

IF Editar THEN
dw_Ingreso.Modify("DataWindow.ReadOnly=NO")
ELSE
dw_Ingreso.Modify("DataWindow.ReadOnly=YES")
END IF
cb_Editar.Enabled = Not Editar

cb_Nuevo.Enabled = Not Editar
cb_Eliminar.Enabled = Editar
cb_Guardar.Enabled = Editar
cb_Primero.Enabled = Not Editar

cb_Anterior.Enabled = Not Editar
cb_Siguiente.Enabled = Not Editar
cb_Ultimo.Enabled = Not Editar
wf_editar ()
wf_Modo_Edicion(True)
wf_eliminar ()
Long Pos
Pos = dw_Ingreso.GetRow()
IF Pos > 0 THEN dw_Ingreso.DeleteRow(Pos)
wf_guardar ()
//por modificar en 3 capas
dw_Ingreso.AcceptText()
IF dw_Ingreso.Update() > 0 THEN
commit;
ELSE
MessageBox("Error: ", "No se Pudo actualizar" + Sqlca.SqlErrText )

rollback;
END IF
wf_Modo_Edicion(False)
wf_anterior ()
dw_Ingreso.ScrollPriorRow( )
wf_primero ()
IF dw_Ingreso.RowCount()>=1 THEN dw_Ingreso.ScrollToRow(1)
wf_siguiente ()
dw_Ingreso.ScrollNextRow()
wf_ultimo ()
IF dw_Ingreso.RowCount()>=1 THEN
dw_Ingreso.ScrollToRow(dw_Ingreso.RowCount())
Luego de “w_class_registrador” heredamos a: w_categoria, w_cliente,
w_compra, w_producto, w_proveedor, w_transportista y w_vendedor
2.5. Ventana MDI y Menú principal.

El menú principal tendrá la siguiente estructura (por el momento faltan los
reportes)
El código para el evento “clicked” de “Registrar Vendedor” es el siguiente:

El código para el evento “clicked” de “Registrar Proveedor” es el siguiente:
El código para el evento “clicked” de “Registrar Transportista” es el siguiente:
Y así sucesivamente para cada una de las ventanas de la aplicación.
2.6. Gestión de Reportes.

(Pendiente)

III. Arquitectura Distribuida y EAServer
3.1. Desarrollo de Aplicaciones n-Tier con PowerBuilder

El proceso de Desarrollar aplicaciones distribuidas con PB y EAServer es el
siguiente:
Tareas en
EAServer
1. Crear Servidor (Opcional)

2. Crear Package
3. Crear Caché de Conexiones
Tareas en
Target Servidor
4. Definir Componente.
5. Especificar DB (Opcional).
6. Implementar métodos.
7. Desplegar Componente.
Tareas en
Target Cliente
7. Conectar a EAServer.
8. Generar Proxy de Componentes.
9. Instanciar el Proxy
10. Enviar Mensajes.
3.2. Creación de Servidores EAServer

Para crear un Servidor EAServer Primero debemos conectarnos al “Jaguar”
mediante la Consola de Administración de EAServer “EAServer Manager”:

Con lo que se iniciará el servidor EAServer mostrando la siguiente pantalla:

Ahora debemos acceder al servidor, para lo cual en una ventana del explorador
digitaremos esta dirección: “http://WINCAMILO:8000”, mostrándonos la
siguiente pantalla, que indica que el servidor está operacional:
La ventana principal del EAServer nos muestra diferentes opciones como

documentación local y en línea, entre otros. Hacemos clic en “Web
Administration Console” e ingresamos las credenciales de acceso, en username
ponemos “admin@system” y en password: “easerver6”

Clic en <Login> y aparecerá el siguiente diálogo:
Expandimos la pestaña de Servidores y vemos el servidor por defecto y el

servidor creado al momento de la instalación:

Seleccionamos la carpeta “Servers”, hacemos <clic derecho> y se muestra:
Con fines didácticos crearemos un nuevo Servidor, clic en <Add>:

Clic en <Siguiente> y le damos nombre “EAS_VentaPC”:
Clic en siguiente donde debemos escoger el puerto por el cual atenderá el servidor
de aplicaciones de ejemplo, cada servidor de aplicaciones debe atender por un
puerto diferente:

Clic en <Add Listener>, especificamos tipo: http y puerto: 8050.
Clic en <Add Listener>, especificamos tipo: iiop y puerto: 2050

Clic en <Siguiente> y dejamos las opciones por defecto:

Nos muestra los módulos EAServer activos por defecto, Clic en <Siguiente>:
Indicamos si deseamos excluir algún módulo, Clic en <Siguiente>:

Nos muestra una ventana resumen:
Clic en <Finalizar> y nos muestra el servidor recién creado:

Para iniciar el servidor ejemplo, debemos crear un acceso directo en el escritorio

que contenga el siguiente comando:
"C:\Program Files\Sybase\EAServer6\bin\start-server.bat" EAS_VentaPC
Al darle doble clic inicia el servidor y atiende por los puertos configurados:

Y tiene su propia consola de administración:
En lo que resta del curso trabajaremos con el Servidor “WINCAMILO”.
3.3. Creación de Packages

Se denomina “Package” a un grupo de componentes relacionados, es una
colección de componentes que trabajan juntos para proveer algún aspecto de la
lógica de negocios de la aplicación.
Un Package define un límite de confianza dentro del cual los componentes pueden
comunicarse fácilmente.
Para crear el Package de nuestro caso de estudio seleccionamos el fólder

“CORBA Packages” y hacemos <clic derecho> obteniendo:


Clic en <Agregar> y nos aparece el asistente de creación de Package:
Clic en <Next> y ponemos el nombre “VentaPC” al nuevo Package:

Clic en <Siguiente> y obtenemos:
Clic en <Finalizar> para terminar con el asistente:

3.4. Creación de Caché de Conexiones

A través del caché de conexiones los componentes comparten un conjunto de
conexiones preestablecidas a servidores de base de datos remotas.
Preestablecer conexiones y limitar el número de veces que una conexión física

necesita ser creada y destruida en un entorno impredecible de carga, son
actividades críticas para un desempeño eficiente.
Para crear un caché de conexiones expandimos la carpeta “Resources” y clic

derecho sobre la carpeta “Data Sources”:
En el menú contextual, seleccionamos la opción “Add”, abriendo el asistente para

la creación de nuevas fuentes de datos:

Clic en el botón <Siguiente>, establecemos el nombre de nuestro data source

“VentaPC”:


Clic en <Siguiente> y establecemos el tamaño mínimo y máximo del pool de

conexiones en 5 y 10 respectivamente:
Seleccionamos el servidor(es) donde el Pool de conexiones estará disponible:

Clic en <Siguiente> y Muestra un resumen de lo que se hará:
Clic en <Finalizar>:

Se edita como sigue a continuación:
Clic en <Aplicar>, hacemos clic derecho sobre lo que hemos creado:

Clic en el menú Ping y nos devuelve un mensaje de conformidad:
Con lo cual hemos creado un pool de conexiones.
3.5. Perfiles de conexión a EAServer en PowerBuilder IDE

Antes de crear un perfil de conexión debemos verificar que el Servidor EAServer
se encuentre atendiendo; para lo cual verificamos la consola del servidor:
En caso de que el servidor no esté iniciado tendremos que iniciarlo con el acceso
directo que se encuentra en el menú inicio:

Luego de que el servicio está corriendo, en PowerBuilder hacemos clic sobre el
ícono de “EAServer Profiles” y aparecerá la siguiente ventana:
Clic en <Agregar…>:

y configuramos la conexión como sigue (Password = easerver6):
Clic en <Probar…> y luego clic en <OK>:
Clic en <Hecho> y ¡listo!

3.6. Definir Componente

Los componentes de la aplicación son administrados en un “Target” creado
específicamente para este propósito, entonces añadiremos a nuestro WorkSpace
un nuevo target llamado “app_VentaPC_NVO”.
Hacemos clic en <Nuevo> y seleccionamos “EAServer Component”:
Clic en <OK>:

Pregunta si se crea de cero o usando una librería existente, seleccionamos “desde

cero” y hacemos clic en <Siguiente>:

Clic en <Siguiente>, creamos la carpeta “SERVER” y dentro de ella creamos el

target y escribimos el nombre de “app_ventapc_nvo”:

Clic en <Siguiente> y escribimos “n_class_controlador”, este objeto no visual

será el padre de todos los demás objetos no visuales, los que contendrán la lógica
de negocio de nuestra aplicación:

Clic en <Siguiente> y seleccionamos el perfil EAServer anteriormente creado, en

el perfil se estableció el servidor de aplicaciones sobre el cual serán desplegados
nuestros componentes:

Clic en <Siguiente> y elegimos el package creado anteriormente, los

componentes se despliegan dentro de packages, lo recomendable es crear un
package por aplicación, en este caso anteriormente se creó “VentaPC”:
Clic en <Siguiente> y seleccionamos el tipo de componente a crear:

Clic en <Siguiente> y especificamos si el componente soportará “Pool de

instancias”, que permite que las instancias del componente se mantengan en
memoria y no se destruyan, disminuyendo así el tiempo de instanciación:

Clic en <Siguiente> y aparece el tipo de transacciones que soportará nuestro

componente, seleccionamos “Supports Transaccition” para que el componente
pueda hacer uso del manejo de transacciones dentro del servidor de aplicaciones,
tal como se muestra:
Clic en <Siguiente> y especificamos que haga una reconstrucción completa, para

que cuando el componente sea desplegado en el servidor vuelva a ser compilado:

Clic en <Siguiente> y seleccionamos que el componente pueda ser editado:
Si queremos que nuestro componente funcione como un WEB Service, debemos

configurar la siguiente pantalla; por el momento no es necesario, clic en
<Siguiente>:


Clic en <Finalizar> y nuestro Workspace queda de la siguiente manera:
Luego en el Target “app_venta_nvo” creamos una librería llamada

“app_venta_nvo_dwingreso.pbl”. Para esto hacemos <clic derecho> sobre el
Target y seleccionamos propiedades:

Clic en <Nuevo> y escribimos “app_venta_nvo_dwingreso”:
Esta nueva librería contendrá los objetos datawindows que finalmente se

presentarán al usuario, dichos datawindows ya no estarán en la aplicación cliente,
sino en el servidor de aplicaciones.
Clic en <Guardar> y <OK> con lo que tenemos:
Clic en <Aceptar> y las librerías quedarían como se muestra:

Luego movemos los objetos DataWindow de “app_venta_dwingreso.pbl” a la

librería “app_venta_nvo_dwingreso.pbl”, y el proyecto quedaría como sigue:

IV. Ciclo de vida y Creación de Componentes
4.1. Modelo del Ciclo de Vida de los Componentes EAServer.

La administración del ciclo de vida de los componentes determina de que manera
las instancias de los componentes son:
 Creadas
 Enlazadas a un Cliente
 Desligadas de un Cliente
 Rehusadas y
 Destruidas.
EAServer soporta las siguientes características en sus componentes:
 Pool de Instancias
 Soporte para componentes Stateful y Stateless.
El Ciclo de vida de los componentes EAServer es como sigue:
Instanciación
En Espera
Activación Reciclamiento
Enlazado a
Cliente
Ejecución de
Método
(Permanece) SI
Desactivación Destrucción
Desactivación Soporta
Automática SI Pool de Inst. NO
NO
Destruido
NO Desactivación
Desactivación
por Primitiva SI

4.2. Creación de los Objetos No Visuales de la Aplicación.

Antes de crear los objetos no visuales debemos crear un Perfil de Conexión a BD
especial, que haga referencia al Caché de conexión en el EAServer y no al DSN
de sistema. Abrimos el administrador de perfiles de conexión:
Clic en <Nuevo> y escribimos “Venta_PC_EAS” como nombre de perfil, luego

Seleccionamos la pestaña “EAServer/COM+” y marcamos como sigue:

Los objetos no visuales (Los controles de los Diagramas de secuencia UML) se

crearán por herencia de “n_class_controlador”. A ésta clase le añadiremos lo
siguiente:
Variables de instancia:

Código a los Eventos “Activate” y “Deactivate”:
También agregaremos funciones de propósito general:

of_recuperar()

of_guardar()
Luego creamos n_cliente, mediante herencia de n_class_controlador:

Hacemos clic en <OK>
Establecemos la propiedad sDataWindow a “d_cliente”:
Hacemos clic en <Guardar> y ponemos nombre “n_cliente”:
Clic en <OK> y listo, se ha creado a n_cliente.

Empleamos el mismo procedimiento para crear los otros objetos: n_categoria,
n_compra, n_producto, n_proveedor, n_transportista, n_vendedor. Y para cada
componente establecemos adecuadamente la propiedad “sDataWindow”; por
ejemplo: para el componente “n_Categoria” el valor de “sDataWindow” será
“d_categoria”; para “n_Vendedor” será “d_vendedor” y así sucesivamente.

Al final tendremos los componentes creados tal como se muestra a continuación:
Luego debemos añadir estos componentes al proyecto “app_venta_nvo” para que

sean desplegados en el EAServer y guardamos:

4.3. Configuración de Componentes EAServer.

Los componentes se configurar
desde la ficha de propiedades del
proyecto, tal como se muestra en las
figuras que siguen.
Desde Powerbuilder existen 3 tipos
de componentes:
Standard: Son el tipo de
componentes más usados y soportan
manejo de transacciones, pool de
instancias y otros aspectos del ciclo
de vida de los componentes
Shared: Permiten mantener
información de estado. Los
componentes Shared permiten que
múltiples clientes compartan la
misma instancia de componente.
Service: Estos componentes realizan procesamiento de fondo para clientes
EAServer y otros componentes. EAServer carga el servicio a momento de iniciar
el servidor.
Hay dos propiedades más que debemos

configurar:
Automatic Demarcation / Deactivation
Cuando está marcado el componente
automáticamente se desactiva después de
cada llamada. Si no está marcado el
componente debe ser desactivado
explícitamente.

Support Instance Pooling: Marcamos

esta propiedad para especificar que
cada instancia del componente
siempre es reutilizada después que
cada cliente la utiliza.
Como paso final de la configuración de los Componentes éstos deben ser
desplegados sobre el EAServer para lo cual desplegamos el proyecto . Y como

resultado podemos apreciar lo siguiente en el Administrador EAServer:

4.4. Creación de Objetos Proxy.

Para que la aplicación cliente pueda invocar a los componentes que se encuentran
en el EAServer primero tenemos que crear sus objetos Proxy respectivos.
Primero Añadimos la librería “app_venta_proxy.pbl” al Target app_venta_gui.
Aparece la lista de librerías del target, aquí añadiremos la nueva librería:

Clic en <New…>
Clic en <Guardar>
Clic en <OK>

Quitamos la referencia a “app_venta_dwingreso.pbl” porque los objetos

datawindow estarán almacenados en el target “app_venta_nvo”:
Clic en <OK> y la estructura del proyecto quedaría así:
Luego hacemos clic en nuevo e iniciamos el asistente para creación de Proxy:

Clic en <OK>:
Clic en <Siguiente> y escribimos “p_venta_proxy”:

Clic en <Siguiente> y seleccionamos el perfil de conexión EAServer:
Clic en <Siguiente>, desplegamos y marcamos VentaPC:

Clic en <Siguiente> y seleccionamos la librería “ventapc_proxy.pbl”:
Clic en <Siguiente> y marcar como sigue:

Clic en <Finalizar>, desplegamos el proyecto y obtenemos:

4.5. FrameWork GUI con Componentes

Debemos modificar el FrameWork GUI para utilizar componentes:
Primero debemos crear nuestro objeto Conexión:
Clic en <OK>:

Clic en <Siguiente>, y seleccionamos la librería donde se guardará el objeto:
Clic en <Siguiente>, y especificamos que requerirá de conexión EAServer:

Clic en <Siguiente> y seleccionar el package “VentaPC”:

Clic en <Siguiente>, especificamos “n_connect” como nombre:

Clic en <Finalizar> y obtenemos un nuevo objeto conexión:
En la Aplicación creamos una variable global:

Modificamos el evento open de la aplicación:
También modificamos el evento close de la aplicación
A la clase “w_padre” le añadiremos dos variables de instancia:
A la clase “w_class_registrador” le modificamos las funciones wf_recuperar y

wf_guardar, para que trabajen con los objetos proxy provenientes del servidor, las
modificaciones son tal como se muestran a continuación:




PB Distribuido Manual v2016 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

PB Distribuido Manual v2016 PDF

Cargado por

Copyright:

Formatos disponibles

Facultad de Ingeniería

EAP Ingeniería de Sistemas e Informática

Creación de Aplicaciones Distribuidas con

Primera Parte - Arquitectura Distribuida

Ms. Ing. Camilo E. Suárez Rebaza 2

I. Creación y Programación de Base de Datos

1.1. Descripción del Caso de Estudio

Confirmar Cotización Emitir Guia de Remisión

Vendedor Reportar Pendientes

Registrar Producto Emitir Comprobante

Reportar Ingresos Cajero

El Caso de Estudio tiene las siguientes restricciones:

Ms. Ing. Camilo E. Suárez Rebaza 3

1.2. Creación de la Base de Datos

Ms. Ing. Camilo E. Suárez Rebaza 4

En la interface de Sybase Central hacemos <Doble Clic> sobre

Ms. Ing. Camilo E. Suárez Rebaza 5

En el menú <Tools> seleccionamos <Create Database>:

Ejecutamos dicha herramienta y obtenemos:

Ms. Ing. Camilo E. Suárez Rebaza 6

Clic en <siguiente> y escribimos la localización de la Base de Datos:

Ms. Ing. Camilo E. Suárez Rebaza 7

Ms. Ing. Camilo E. Suárez Rebaza 8

Ms. Ing. Camilo E. Suárez Rebaza 9

Ms. Ing. Camilo E. Suárez Rebaza 10

Escogemos UTF8 y clic en <siguiente>:

Escogemos UTF8 para datos tipo NChar y clic en <Siguiente>:

Ms. Ing. Camilo E. Suárez Rebaza 11

Establecemos que se ignoren los espacios en blanco en las comparaciones:

Establecemos la clave para el usuario “DBA” a “SQL” y clic en <Siguiente>:

Ms. Ing. Camilo E. Suárez Rebaza 12

Desmarcamos que se conecte a la base de datos y clic en <Siguiente>

Clic en <Finalizar> y Listo:

Ms. Ing. Camilo E. Suárez Rebaza 13

1.3. Creación del Servicio

Para crear el servicio iniciamos la Herramienta Sybase Central y seleccionamos

Dar clic en <Service…> y escribimos “ServerData” para el nombre del servicio:

Ms. Ing. Camilo E. Suárez Rebaza 14

Se escoge el Motor de base de datos en Red y clic en <Siguiente>:

Ms. Ing. Camilo E. Suárez Rebaza 15

Se especifica el ejecutable para Red y clic en <Siguiente>:

Ms. Ing. Camilo E. Suárez Rebaza 16

Ms. Ing. Camilo E. Suárez Rebaza 17

Clic en <Finalizar> finalmente iniciamos el servicio <botón derecho>:

Ms. Ing. Camilo E. Suárez Rebaza 18

1.4. Creación de Tablas, Relaciones e índices.

Clic en <Connect…> y digitamos “dba” y “Sql”:

Ms. Ing. Camilo E. Suárez Rebaza 19

Parámetro Valor Explicación

Action Connect to a running Conectar a una base de datos cuyo

Ms. Ing. Camilo E. Suárez Rebaza 20

Clic en <Conectar> y obtenemos lo siguiente:

Clic en el fólder Tables y luego <clic derecho> y aparece el siguiente menú:

Ms. Ing. Camilo E. Suárez Rebaza 21

Clic en <Table…> y damos el nombre de la tabla “Categoria”:

Ms. Ing. Camilo E. Suárez Rebaza 22

Ms. Ing. Camilo E. Suárez Rebaza 23

Clic en <Finalizar>, presentándonos la interface para el ingreso de los campos.

Ms. Ing. Camilo E. Suárez Rebaza 24

Luego agregamos el campo <Descripción> y guardamos la tabla :

Ms. Ing. Camilo E. Suárez Rebaza 25

Clic en <Foreign Key…>, Seleccionamos la tabla “padre”, y para el caso de esta

Ms. Ing. Camilo E. Suárez Rebaza 26