pb distribuido - manual v2014 - parte i

Creación de Aplicaciones Distribuidas con

PowerBuilder y EAServer

Versión 2014

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

Ms. Ing. Camilo E. Suárez Rebaza Manual del Estudiante. Versión 2014

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




3

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.

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.

Vendedor

Cotizar Productos

Administrador

Registrar Compra

Registrar Vendedores

Emitir Guia de Remisión

Cajero

Emitir Comprobante

Almacenero

Confirmar Cotización

Registrar Transportista

Pedir Productos

Registrar Producto

Registrar Proveedor

Reportar Pendientes

Reportar Ingresos




4

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:

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):

Cliente

ID_Cliente

Apellidos

Nombres

Direccion

e_mail

telefono

bigint

varchar(40)

varchar(50)

varchar(100)

varchar(30)

varchar(15)

<pk>

Proveedor

RUC

Razon

Direccion

Telefono

char(12)

varchar(100)

varchar(100)

varchar(15)

<pk>

Cotizacion

ID_Cotizacion

ID_Cliente

ID_Vendedor

Fecha

F_Vencimiento

bigint

bigint

smallint

date

date

<pk>

<fk1>

<fk2>

Compras

ID_Compra

ID_Producto

RUC

NroGuia

Cantidad

PrecioUnit

bigint

bigint

char(12)

varchar(20)

smallint

money

<pk>

<fk2>

<fk1>

Cotizacion_Detalle

ID_Cotizacion

ID_Producto

Cantidad

Precio

bigint

bigint

smallint

money

<pk,fk1>

<pk,fk2>

Transportista

ID_Transportista

RUC

Razon

Telefono

smallint

varchar(12)

varchar(80)

varchar(15)

<pk>

Vendedor

ID_Vendedor

Apellidos

Nombres

Direccion

F_Ingreso

Estado

smallint

varchar(40)

varchar(50)

varchar(100)

date

smallint

<pk>

Boleta_Detalle

ID_Boleta

ID_Producto

Cantidad

Precio

SubTotal

bigint

bigint

smallint

money

money

<pk,fk1>

<pk,fk2>

GuiaSalida

ID_GuiaSalida

ID_Transportista

ID_Boleta

ID_Factura

bigint

smallint

bigint

bigint

<pk>

<fk1>

<fk2>

<fk3>

Boleta

ID_Boleta

ID_Cliente

Fecha

Total

Estado

bigint

bigint

date

money

smallint

<pk>

<fk>

Producto

ID_Producto

ID_Categoria

Descripcion

StockActual

StockMinimo

PrecioActual

Comentarios

bigint

smallint

varchar(100)

integer

integer

money

varchar(500)

<pk>

<fk>Categoria

ID_Categoria

Descripcion

smallint

varchar(100)

<pk>

Factura

ID_Factura

ID_Cliente

Fecha

Total

Estado

bigint

bigint

date

money

smallint

<pk>

<fk>

Factura_Detalle

ID_Factura

ID_Producto

Cantidad

Precio

SubTotal

bigint

bigint

smallint

money

money

<pk,fk1>

<pk,fk2>




5

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




6

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

Ejecutamos dicha herramienta y obtenemos:




7

Clic en <siguiente>:

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




8

Clic en <Siguiente>:

Clic en siguiente:




9






10

Clic en siguiente:

Clic en siguiente:




11

Escogemos UTF8 y clic en <siguiente>:

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




12

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

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




13

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

Clic en <Finalizar> y Listo:




14

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:




15

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




16

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





17






18


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




19

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”:




20

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

database on this

computer

Conectar a una base de datos cuyo

servidor está en esta computadora

Server

Name

ServerData Es el nombre del servidor de datos al

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

Name

VentaPC Como un servidor de datos puede

administrar varias base de datos, aquí

especificamos a cuál de ellas nos

vamos a conectar




21

Clic en <Conectar> y obtenemos lo siguiente:

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




22

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





23






24


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:




25

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ú:




26

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

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




27

Especificamos el nombre “Categoria_Producto_FK”, luego clic en <Siguiente>:

Aquí nos indica que se va crear la columna “ID_Categoria”, Clic en <Siguiente>:




28


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




29






30

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.




31

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”:




32





33


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:




34

Para agregar Boleta:

Para agregar Cliente:

Para agregar Cotización:




35

Para agregar Factura:

Para agregar Producto:

Para agregar Proveedor:




36

Para agregar Transportista:

Para agregar Vendedor:




37

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:




38

Clic en <Siguiente> y marcamos <Insert>:


Clic en <Siguiente> y marcamos <After Event>




39


Clic en <Finalizar> y escribimos el siguiente código:

Luego guardamos y listo, el Trigger ha sido creado, ahora añadiremos otro:




40

Hacemos clic en <Nuevo…> y escribimos “tU_Compras_ActualizarProducto”:

Clic en <Siguiente> y marcamos <Actualización de columnas> (precio y

cantidad):





41

Clic en <Siguiente> y marcamos <después del evento>:


Clic en <Finalizar> y escribimos el siguiente código:




42

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>:




43


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





44

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




45

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”:




46

Clic en <OK>, seleccionamos una ruta y ponemos el nombre “VentaPC”:

Luego procedemos a agregar un target de aplicación:




47

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

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




48

Agregamos un archivo de librería, para almacenar los datawindows:

Clic en <OK> y le ponemos “app_venta_dwingreso”:




49

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)




50

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:




51




52

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:




53

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

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




54

Clic en <OK>:

Luego seleccionamos la tabla “Cliente”

Clic en <Abrir> y configuramos la consulta de la siguiente manera:




55

Luego configuramos la presentación del Datawindow:

Y guardamos con el nombre “d_cliente”.




56

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




57

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”




58

Hacemos clic en <OK>:

Ahora a cada argumento del procedimiento almacenado lo relacionamos con un

campo del DataWindow:




59

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:




60

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




61

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 )




62

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:




63

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)




64

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:

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”:

4. Definir Componente.

5. Especificar DB (Opcional).

6. Implementar métodos.

7. Desplegar Componente.

1. Crear Servidor (Opcional)

2. Crear Package

3. Crear Caché de Conexiones

Tareas en

EAServer

7. Conectar a EAServer.

8. Generar Proxy de Componentes.

9. Instanciar el Proxy

10. Enviar Mensajes.

Tareas en

Target Servidor

Tareas en

Target Cliente




65

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




66

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”

http://wincamilo:8000/




67

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:




68

Seleccionamos la carpeta “Servers”, hacemos <clic derecho> y se muestra:

Con fines didácticos crearemos un nuevo Servidor, clic en <Add>:




69

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:




70

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

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




71

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





72

Nos muestra los módulos EAServer activos por defecto, Clic en <Siguiente>:

Indicamos si deseamos excluir algún módulo, Clic en <Siguiente>:




73

Nos muestra una ventana resumen:

Clic en <Finalizar> y nos muestra el servidor recién creado:




74

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:




75

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:




76




77

Clic en <Agregar> y nos aparece el asistente de creación de Package:

Clic en <Next> y ponemos el nombre “VentaPC” al nuevo Package:




78

Clic en <Siguiente> y obtenemos:

Clic en <Finalizar> para terminar con el asistente:




79

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:




80

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

“VentaPC”:




81






82

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:




83

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

Clic en <Finalizar>:




84

Se edita como sigue a continuación:

Clic en <Aplicar>, hacemos clic derecho sobre lo que hemos creado:




85

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:




86

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…>:




87

y configuramos la conexión como sigue (Password = easerver6):

Clic en <Probar…> y luego clic en <OK>:

Clic en <Hecho> y ¡listo!




88

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>:




89

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

cero” y hacemos clic en <Siguiente>:





90

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

target y escribimos el nombre de “app_ventapc_nvo”:





91


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:




92


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:




93

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:




94


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:




95

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:




96

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>:




97






98

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:




99

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:




100

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:




101

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

Enlazado a

Cliente

Activación

Desactivación

Automática

Desactivación

por Primitiva

NO

Soporta

Pool de Inst.

Ejecución de

Método

Reciclamiento

NO

Desactivación

Desactivación

SI

NO

Destruido

Destrucción

(Permanece)

SI

SI




102

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:




103

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:




104

Código a los Eventos “Activate” y “Deactivate”:

También agregaremos funciones de propósito general:

of_recuperar()




105

of_guardar()

Luego creamos n_cliente, mediante herencia de n_class_controlador:




106

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.




107

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:




108

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.




109

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:




110

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:




111

Clic en <New…>

Clic en <Guardar>

Clic en <OK>




112

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:




113

Clic en <OK>:

Clic en <Siguiente> y escribimos “p_venta_proxy”:




114

Clic en <Siguiente> y seleccionamos el perfil de conexión EAServer:

Clic en <Siguiente>, desplegamos y marcamos VentaPC:




115

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

Clic en <Siguiente> y marcar como sigue:




116


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




117

4.5. FrameWork GUI con Componentes

Debemos modificar el FrameWork GUI para utilizar componentes:

Primero debemos crear nuestro objeto Conexión:

Clic en <OK>:




118

Clic en <Siguiente>, y seleccionamos la librería donde se guardará el objeto:

Clic en <Siguiente>, y especificamos que requerirá de conexión EAServer:




119


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




120

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





121


Clic en <Finalizar> y obtenemos un nuevo objeto conexión:

En la Aplicación creamos una variable global:




122

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:




123




124

pb distribuido - manual v2014 - parte i

Documents

creacin de componentes

creacin de funciones

creacin de tablas

creacin de cach

creacin de triggers

creacin de packages

creacin de servidores

creacin de objetos proxy