Universidad Nacional del Nordeste Facultad de Ciencias Exactas y Naturales y de Agrimensura Licenciatura en Sistemas de Información Trabajo Final de Aplicación

Aplicación Web para la Gestión Agro-Ganadera

Alumno: Lisandro Dardo Yaccuzzi - LU:32774
Profs. Orientadores: Mgter. David L. La Red Martinez y Lic. Valeria E. Uribe Prof. Coordinador: Agr. Castor F. Herrmann

Corrientes - Argentina Julio - 2010

A mi familia, esposa e hija.

Prefacio
Los diversos avances tecnológicos derivados del conocimiento y la ciencia están siendo aplicados en varios países del mundo a distintos sectores nunca antes imaginados, entre ellos el sector de la agricultura y la ganadería en Argentina. A esto se le suma el empleo de herramientas con tecnología de avanzada que ya se encuentran a disposición de todos en cualquier momento y lugar que se las requieran, para poder de esta forma mantener la competitividad a nivel mundial con una producción sustentable en el tiempo. Todo lo señalado precedentemente sería ilusorio si no se dispusiera de las metodologías y de los sistemas informáticos que facilitaran la información entre las distintas organizaciones empresariales, utilizando diversos medios de comunicación y diferentes plataformas de hardware y de software, para resolver el problema de la creciente complejidad de la gestión de un establecimiento agrícola-ganadero en continua expansión. Este trabajo se basa en el estudio de software de base que permite el desarrollo de aplicaciones Web multiplataforma con acceso a bases de datos y en el desarrollo de una aplicación Web de gestión de un establecimiento agro-ganadero. Contempla el registro y seguimiento de la información propia del establecimiento como todas las actividades realizadas en el mismo, es decir la información emergente del registro de cada actividad que se genera en el mismo, el seguimiento detallado de cada actividad registrada, paso a paso, a los efectos de brindar información a los usuarios finales de los movimientos realizados, también a su vez da información, mediante consultas a la aplicación, de los datos ingresados por cada actividad, como estado actual, stock y demás. Esto significa la posibilidad de registrar cada actividad con sus datos y fechas en el mismo momento que ocurren para su posterior gestión o consulta, brindando la posibilidad de una consulta desde la Internet por los demás usuarios de la aplicación. Objetivos El objetivo inicialmente planteado fue la realización de una aplicación Web multiplataforma desarrollada en Java, mediante la cual el usuario pudiera contar con un medio de gestión para consultar distintos aspectos del establecimiento en sí, mediante la Web. La aplicación podría ser operada desde una Intranet o bien desde Internet.

Los objetivos planteados al inicio del trabajo, fueron totalmente cumplidos. Etapas de Desarrollo Se ha efectuado una amplia recopilación bibliográfica específica de los temas pertinentes a la tarea planificada y a los productos de software que se emplearon para la concreción del Trabajo Final. Se realizaron las traducciones de los manuales correspondientes a la herramienta de desarrollo Eclipse, versión 5.0 para Windows. Se ha realizado un detallado estudio del lenguaje Java, utilizándose la versión JDK 1.5. Se ha realizado un detallado estudio del entorno de trabajo Scientific WorkPlace 2.5.0 para la escritura del libro correspondiente al informe final. Se ha realizado un detallado estudio del software para el desarrollo de la aplicación, es decir el estudio de la plataforma integrada de desarrollo de aplicaciones Web, Eclipse. Se ha realizado el estudio del Manejador de Bases de Datos (DBMS) multiplataforma DB2 Express-C 9. Se ha realizado el desarrollo de la aplicación utilizando páginas HTML y Servlets de Java en el marco de la herramienta Eclipse en el entorno Windows. Se ha realizado el correspondiente testeo de la aplicación, utilizando una máquina como servidor y otra como cliente ingresando a la base de datos del servidor a través de la Intranet de la Facultad. Una vez finalizada la aplicación se realizó la grabación en DVD de todo el material correspondiente al trabajo final: una versión de la aplicación, otra referente al libro en formato LaTex y el PDF generado. También se icluyó los instaladores de los productos utilizados para el desarrollo, es decir DB2 Express-C 9, Eclipse y Tomcat. Objetivos Logrados Se han alcanzado plenamente la totalidad de los objetivos planteados para el presente trabajo.

Organización del Informe Final El informe final comprende un libro impreso y un DVD, además de un resumen y de un resumen extendido. El libro impreso está organizado en capítulos, los que se indican a continuación: Capitulo 1 - La Agro-Ganadería en la Actualidad: Se presenta una visión general de los conceptos sobre la tecnología aplicada al sector agro-ganadero. Capitulo 2 - Conceptos básicos sobre Java: Se señalan los principales conceptos referidos al lenguaje de programación. Capitulo 3 - El lenguaje Java: Se indican los principales aspectos y destacadas características referidas al lenguaje. Capitulo 4 - Los Servlets: Se resumen los aspectos y características más destacadas de estas facilidades. Capitulo 5 - Introducción a DB2 Express-C 9: Se detallan las más relevantes características de esta familia de productos de gestión de bases de datos multiplataforma. Capitulo 6 - Eclipse: Se presentan los principales aspectos de este entorno de desarrollo de aplicaciones complejas. Capitulo 7 - Introducción al Servidor Tomcat: Se señalan los aspectos más relevantes de este servidor de aplicaciones Web. Capitulo 8 - Aplicación: Se detallan los aspectos más significativos de la aplicación desarrollada utilizando las facilidades antes mencionadas. Capitulo 9 - Conclusiones: Se presentan las conclusiones a las que se ha llegado al finalizar el presente trabajo y las posibles líneas futuras. El DVD, adjunto al libro impreso, contiene lo siguiente: Instaladores del software utilizado. Resúmenes del trabajo realizado.

Libro del informe final. Presentación para la defensa final. Copia de seguridad de la base de datos de la aplicación. Aplicación desarrollada. Lisandro Dardo Yaccuzzi Licenciatura en Sistemas de Información Universidad Nacional del Nordeste L.U.: 32774 Profs. Orientadores: Mgter. David Luis La Red Martínez y Lic. Valeria E. Uribe Prof. Coordinador: Agr. Castor F. Herrmann Corrientes; 01 de Mayo de 2010

Índice general
1. La Agro-Ganadería en la Actualidad 1.1. La Agricultura y la Ganadería en el Mundo y en Argentina 1.2. La Agricultura, la Máquina Reemplaza al Músculo . . . . . 1.2.1. Agricultura de Precisión . . . . . . . . . . . . . . . . 1.3. La Evolución de la Ganadería . . . . . . . . . . . . . . . . . 1.3.1. Ganadería Extensiva e Intensiva . . . . . . . . . . . 2. Conceptos Básicos de Java 2.1. ¿Qué es Java y Para qué fue Pensado? . . . . . . . 2.1.1. Características del Lenguaje Java . . . . . . 2.1.2. Desarrollo de las Principales Características 2.1.3. Ventajas de Java . . . . . . . . . . . . . . . 2.1.4. Limitaciones con Java . . . . . . . . . . . . 2.1.5. Errores con Java . . . . . . . . . . . . . . . 2.2. Existen Distintos Tipos de Java . . . . . . . . . . . 2.2.1. JavaScript . . . . . . . . . . . . . . . . . . . 2.2.2. Java Standalone . . . . . . . . . . . . . . . 2.2.3. Applets . . . . . . . . . . . . . . . . . . . . 2.3. Java en los Browsers de la World Wide Web . . . . 2.3.1. Las Applets en la Web . . . . . . . . . . . . 2.3.2. Máquinas Virtuales . . . . . . . . . . . . . . 2.3.3. Java sin Browsers . . . . . . . . . . . . . . . 2.3.4. HotJava . . . . . . . . . . . . . . . . . . . . 2.4. Java en Hebras - Threads . . . . . . . . . . . . . . 2.4.1. La Ventaja de ser Multi-Threaded . . . . . 2.5. Java Para Aplicaciones Corporativas . . . . . . . . . . . . . . . . . . de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 4 5 7 11 11 12 13 18 19 19 20 20 21 21 23 23 26 28 29 29 30 31

3. El Lenguaje Java 34 3.1. Introducción a su Codificación . . . . . . . . . . . . . . . . . . 34

ÍNDICE GENERAL

3.1.1. Bibliotecas de Clases Estándares de Java 3.2. Estructura General de un Programa Java . . . . 3.3. Conceptos Básicos . . . . . . . . . . . . . . . . . 3.3.1. Clase . . . . . . . . . . . . . . . . . . . . 3.3.2. Herencia . . . . . . . . . . . . . . . . . . . 3.3.3. Interface . . . . . . . . . . . . . . . . . . . 3.3.4. Package . . . . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

36 36 38 38 38 39 40 41 42 44 45 45 46 46 46 47 48 49 50 50 50 52 52 52 53 57 57 58 60 60 61 62 63 63 63 63 64

3.4.

3.5.

3.6.

3.7.

3.8.

3.3.5. La Jerarquía de Clases de Java (API) . . . . . . . . . . 3.3.6. Variables Dentro del Lenguaje Java . . . . . . . . . . . 3.3.7. Visibilidad y Vida de las Variables . . . . . . . . . . . . Operadores en Java . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1. Operadores Aritméticos . . . . . . . . . . . . . . . . . . 3.4.2. Operadores de Asignación . . . . . . . . . . . . . . . . . 3.4.3. Operadores Unarios . . . . . . . . . . . . . . . . . . . . 3.4.4. Operadores Incrementales . . . . . . . . . . . . . . . . . 3.4.5. Operadores Relacionales . . . . . . . . . . . . . . . . . . 3.4.6. Operador de Concatenación de Cadenas de Caracteres (+) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.7. Precedencia de Operadores . . . . . . . . . . . . . . . . Estructuras de Programación . . . . . . . . . . . . . . . . . . . 3.5.1. Sentencias o Expresiones . . . . . . . . . . . . . . . . . . 3.5.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . 3.5.3. Sentencia import . . . . . . . . . . . . . . . . . . . . . . 3.5.4. Longitud de Líneas . . . . . . . . . . . . . . . . . . . . . 3.5.5. Bifurcaciones . . . . . . . . . . . . . . . . . . . . . . . . 3.5.6. Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clases en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.1. Características Importantes de las Clases . . . . . . . . 3.6.2. Métodos o Funciones Miembros . . . . . . . . . . . . . . Clases de Mayor Utilidad . . . . . . . . . . . . . . . . . . . . . 3.7.1. Clase Arrays . . . . . . . . . . . . . . . . . . . . . . . . 3.7.2. Clases String y StringBuffer . . . . . . . . . . . . . . . . 3.7.3. Clase Double . . . . . . . . . . . . . . . . . . . . . . . . 3.7.4. Clase Integer . . . . . . . . . . . . . . . . . . . . . . . . El AWT (Abstract Windows Toolkit) . . . . . . . . . . . . . . . 3.8.1. Qué es el AWT . . . . . . . . . . . . . . . . . . . . . . . 3.8.2. Creación de una Interface Gráfica de Usuario . . . . . . 3.8.3. Objetos “event source” y Objetos “event listener” . . .

ÍNDICE GENERAL

3.8.4. Proceso a Seguir Para Crear Una Aplicación Interactiva (Orientada a Eventos) . . . . . . . . . . . . . . . . . . . 3.9. Errores Frecuentes de Programación . . . . . . . . . . . . . . . 3.9.1. Scheduling de Hilos de Ejecución . . . . . . . . . . . . . 3.9.2. Errores en el Uso de las Características de Portabilidad de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.3. Uso de Directorios Definidos . . . . . . . . . . . . . . . 3.9.4. Carga de Drivers JDBC . . . . . . . . . . . . . . . . . . 3.9.5. Terminación de Líneas . . . . . . . . . . . . . . . . . . . 3.9.6. Entrada/Salida por Archivo . . . . . . . . . . . . . . . . 3.9.7. Fuentes de Caracteres . . . . . . . . . . . . . . . . . . . 4. Los Servlets 4.1. Servlets . . . . . . . . . . . . . . . . . . . . . . 4.1.1. Principios de Codificación de Servlet . 4.1.2. Ciclo de Vida del Servlet . . . . . . . . 4.1.3. Instanciación e Inicialización . . . . . . 4.1.4. Servicio de Demanda . . . . . . . . . . . 4.1.5. Terminación . . . . . . . . . . . . . . . . 4.1.6. Modelos de Acceso JSP . . . . . . . . . 4.1.7. Procesadores JSP . . . . . . . . . . . . . 4.1.8. Compilación Batch de Archivos JSP . . 4.1.9. Desarrollando Aplicaciones . . . . . . . 4.1.10. Fases de Inicialización y de Terminación 4.1.11. Rasgos de Java Servlet API . . . . . . . 4.1.12. Patrones y Guías de Servlets/JSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

65 65 66 67 68 71 72 73 73 74 74 75 76 76 78 78 78 79 81 81 82 82 83

5. Introducción al DB2 Express-C 9 87 5.0.13. Servidores DB2 . . . . . . . . . . . . . . . . . . . . . . . 88 5.0.14. Clientes DB2 y Controladores . . . . . . . . . . . . . . . 89 5.0.15. Características y Productos Relacionados . . . . . . . . 90 5.0.16. Características incluídas en otras ediciones de DB2: . . 90 5.0.17. Características Incluidas con la Licencia de Suscripción de DB2 Express-C . . . . . . . . . . . . . . . . . . . . . 92 5.0.18. Características No Disponibles con DB2 Express-C . . . 94 5.0.19. Productos Pagados Relacionados con DB2 . . . . . . . . 96 5.0.20. Guía de Instalación de DB2 Express C . . . . . . . . . . 97 5.0.21. Herramientas de DB2 . . . . . . . . . . . . . . . . . . . 102 6. Eclipse 109

ÍNDICE GENERAL

6.1. ¿Que es Eclipse? . . . . . . . . . . . . . . . . . . . . . . . . . . 109 6.2. ¿Como Utilizar Eclipse? . . . . . . . . . . . . . . . . . . . . . . 110 7. Tomcat 7.1. Descripción . . . . . . . . . 7.2. Entorno . . . . . . . . . . . 7.3. Estado de su Desarrollo . . 7.4. Estructura de Directorios . 7.5. Características del Producto 7.6. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 114 114 115 115 115 116 118 118 118 119 120 130 135 136 138 139 140 141 142 158 158

8. Descripción de la Aplicación 8.1. Descripción General . . . . . . . . . . 8.2. Análisis . . . . . . . . . . . . . . . . . 8.3. Desarrollo . . . . . . . . . . . . . . . . 8.3.1. Módulos . . . . . . . . . . . . . 8.3.2. Ganadería . . . . . . . . . . . . 8.3.3. Empleados . . . . . . . . . . . 8.3.4. Bancos . . . . . . . . . . . . . . 8.3.5. Clientes . . . . . . . . . . . . . 8.3.6. Proveedores . . . . . . . . . . . 8.3.7. Consultas . . . . . . . . . . . . 8.3.8. Planillas . . . . . . . . . . . . . 8.4. Estructura de Datos . . . . . . . . . . 8.5. Ejemplos de Código Fuente Utilizados 8.5.1. Servlets y HTML embebido . .

9. Conclusiones 171 9.1. Conclusiones Acerca de las Tecnologías y Software Utilizados . 171 9.2. Líneas Futuras de Acción . . . . . . . . . . . . . . . . . . . . . 172

Bibliografía Índice alfabético

173 174

Índice de figuras
1.1. 1.2. 1.3. 1.4. 1.5. 2.1. 2.2. 2.3. 2.4. 2.5. 2.6. 2.7. 3.1. 3.2. 3.3. 3.4. La Agricultura Ayer y Hoy. . . . . . . . . . . . . . Distintos Dispositivos Tecnológicos Utilizados en la La Agricultura de Precisión. . . . . . . . . . . . . . Ganadería de Corral. . . . . . . . . . . . . . . . . . Ganadería Extensiva e Intensiva. . . . . . . . . . . Logo de Java. . . . . . . . . . . . . . . . Arquitectura Cliente - Servidor. . . . . . Bytecode y JVM. . . . . . . . . . . . . . Netscape Navigator - Internet Explorer. JIT - Just In Time. . . . . . . . . . . . HotJava. . . . . . . . . . . . . . . . . . . Clase Thread. . . . . . . . . . . . . . . . Herencia en Java. . . . . . . . . Típicos Packages Predefinidos. API de Java. . . . . . . . . . . JDBC en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Agricultura. 4 . . . . . . . 5 . . . . . . . 7 . . . . . . . 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 24 26 27 28 29 31 39 41 42 71 77 79 80

4.1. Ciclo de Vida de un Servlet. . . . . . . . . . . . . . . . . . . . . 4.2. Requerimiento de un Archivo JSP. . . . . . . . . . . . . . . . . 4.3. Requerimiento de un Servlet. . . . . . . . . . . . . . . . . . . . 5.1. 5.2. 5.3. 5.4. 5.5. 5.6. 5.7. Servidores DB2. . . . . . . . . . . Réplica de SQL. . . . . . . . . . DB2 Connect. . . . . . . . . . . . WebSphere Federation Server. . . Ventana de Progreso en DB2. . . Herramientas DB2. . . . . . . . . Herramientas DB2: Menú Inicio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. 89 . 94 . 96 . 98 . 101 . 102 . 103

ÍNDICE DE FIGURAS

5.8. Centro de Control de DB2. . . 5.9. Icono DB2 en Windows. . . . . 5.10. Editor de Comandos. . . . . . . 5.11. Botón Show SQL. . . . . . . . . 5.12. Salida de un Botón Show SQL.

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

104 106 106 107 108 119 119 120 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 158

8.1. Diagrama de Contexto . . . . . . . . . . . . . . . . . 8.2. Caso de Uso. . . . . . . . . . . . . . . . . . . . . . . 8.3. Página Principal de la Aplicación. . . . . . . . . . . 8.4. Formulario de Agricultura. . . . . . . . . . . . . . . 8.5. Formulario de Carga Cosecha a Terceros. . . . . . . 8.6. Formulario de Carga Siembra Propia. . . . . . . . . 8.7. Formulario de Carga Rollos Propios. . . . . . . . . . 8.8. Formulario de Modificar Máquinas. . . . . . . . . . . 8.9. Formulario de Carga Pulverizaciones a Terceros. . . 8.10. Formulario de Carga Campos Propios. . . . . . . . . 8.11. Principal de Insumos. . . . . . . . . . . . . . . . . . 8.12. Principal de Ventas. . . . . . . . . . . . . . . . . . . 8.13. Pantalla Principal de Ganadería. . . . . . . . . . . . 8.14. Pantalla Principal de la Sección Ganado. . . . . . . . 8.15. Formularios de Vacunación y Baño de Ganado. . . . 8.16. Formulario de Carga de Inseminaciones de Ganado. . 8.17. Formularios de Reproducción y Balanza. . . . . . . . 8.18. Página Principal de Empleados. . . . . . . . . . . . . 8.19. Página Principal del Módulo Bancos. . . . . . . . . . 8.20. Operaciones Financieras. . . . . . . . . . . . . . . . . 8.21. Principal de Clientes. . . . . . . . . . . . . . . . . . . 8.22. Principal de Proveedores. . . . . . . . . . . . . . . . 8.23. Ejemplos de Listados Arrojados por el Sistema. . . . 8.24. Ejemplo de Planillas Disponibles en el Sistema. . . . 8.25. Estructura de la Base de Datos. . . . . . . . . . . . . 8.26. Tablas de la Base de Datos SAG. . . . . . . . . . . .

Índice de cuadros
3.1. 3.2. 3.3. 3.4. 3.5. 3.6. Tipos de Variables. . . . . . . . Categorías de Variables. . . . . Tipos Primitivos de Variables. . Operadores de Asignación. . . . Operadores Relacionales. . . . . Precedencia de Operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 43 44 46 47 49

5.1. Comandos Para Iniciar Algunas Herramientas DB2. . . . . . . 103

Capítulo 1

La Agro-Ganadería en la Actualidad
1.1. La Agricultura y la Ganadería en el Mundo y en Argentina

Los diversos avances tecnológicos derivados del conocimiento y la ciencia están siendo aplicados en varios países del mundo a distintos sectores nunca antes imaginados, entre ellos el sector de la agricultura y la ganadería en Argentina. A esto se le suma el empleo de herramientas con tecnología de avanzada que ya se encuentran a disposición de todos en cualquier momento y lugar que se la requiera, para poder de esta forma mantener la competitividad a nivel mundial con una producción sustentable en el tiempo.

1

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

2

En la actualidad Argentina está obteniendo importantes logros en los sectores de agricultura y ganadería ya que se basan en la incoporación de tecnologías adaptadas exitosamente a la realidad.

1.2.

La Agricultura, la Máquina Reemplaza al Músculo

Anteriormente la actividad agrícola se realizaba con la indispensable ayuda del hombre como herramienta principal para ésta actividad, ya que mediante el mismo se hacía el trabajo en la tierra a mano o traccionado por animales. Hoy en día con la aparición de la maquinaría agrícola, exigentes tareas como la de sembrar y cosechar se pueden realizar de una manera rápida a una escala nunca antes imaginable. Según la Academia Internacional de Ingeniería de EE.UU, la mecanización agraria es uno de los 20 mayores logros de la ingeniería del siglo XX. A principios del siglo XX, se necesitaba un granjero para alimentar de 2 a 5 personas, mientras que hoy, gracias a la tecnología, los agroquímicos y las variedades de cultivos actuales, un granjero puede alimentar a 130 personas. Además de los avances tecnológicos, como se puede observar en la figura 8.4 de la página 122, también se le suman medios de comunicación, servicio meteorológico y estudios de mercado que hacen que el crecimiento del sector agrícola sea exponencial [1].

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

3

Figura 1.1: La Agricultura Ayer y Hoy. Las maquinarias que actualmente se utilizan ya traen incoporados dispositivos tecnológicos de una alta gama, permitiendo de ésta forma tener agricultura de precisión, como por ejemplo: GPS (Global Positioning System). Banderilleros satelitales. Computadoras de pulverización. Higrómetros (miden el grado de humedad). Monitores de siembra. Balanzas electrónicas. Humedímetros y cuenta hectáreas. Software de mapeo. Sistemas de gestión para el agro.

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

4

Figura 1.2: Distintos Dispositivos Tecnológicos Utilizados en la Agricultura.

1.2.1.

Agricultura de Precisión

Consiste en determinar qué requerimientos tienen los suelos, y en qué sitios, y luego poner exactamente la cantidad necesaria de semilla, fertilizante o agroquímicos en el lugar preciso y junto a éstas herramientas poder tomar las correctas decisiones de manejo acerca del tipo de cultivo a realizar, sus rotaciones y fechas de siembra. Hacer Agricultura de Precisión, es hacer lo que siempre se ha estado haciendo pero ahora con mucha mayor precisión, con mucha más información sobre la parcela y sus características. Normalmente los agricultores ya tienen una idea de que áreas de su campo tienen los rendimientos más altos y bajos, pero los trabajos de investigación en la actualidad han mostrado que aún las tierras de altos rendimientos tienen condiciones de suelo variables que producen rendimientos variables. La Agricultura de Precisión usa la Tecnología para medir los rendimientos, determinar las condiciones del suelo y obtener información de cada parte del campo, registrando la ubicación exacta de donde proviene cada dato obtenido. Cada dato de: rendimiento, humedad del grano cosechado, nutrientes del suelo, etc., puede ser llevado a un mapa generado por la computadora, que permite ver más claramente la relación entre varios factores. Luego puede usar la información de estos mapas para determinar los tipos, cantidades, y ubicación de insumos a aplicar.

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

5

Sin embargo, hasta ahora no era posible estudiar cada uno de estos factores debido a que no existía la tecnología necesaria para ello. Gracias al desarrollo de lo que conocemos como “nuevas tecnologías” se puede acometer hoy día el estudio y la gestión de una explotación agrícola de forma integral, considerando el uso de agroquímicos localizada a la zona que realmente hace falta y a la dosis correcta.

Figura 1.3: La Agricultura de Precisión. La Agricultura de Precisión utiliza la tecnología con un objetivo claro “Que los productores tienen ahora la posibilidad de medir exactamente qué está sucediendo en su campo, tomar decisiones más acertadas, basadas en este conocimiento, y así mejorar la eficiencia”.

1.3.

La Evolución de la Ganadería

La Ganadería es una actividad económica de origen muy antiguo que consiste en la crianza de animales para su aprovechamiento. La Argentina ocupa un importante lugar en el mundo como país ganadero, en lo que se refiere a bovinos (el quinto lugar por sus existencias y el tercero como Productor de carne) lo cual le dá una importancia aún mayor. Mediante la selección y el cruzamiento genético se asegura la calidad de las

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

6

razas de bovinos Shorthorn, Heresford, Aberdeen Angus y Holando argentino (para leche); y de ovinos: Merino, Corriedale y Lincoln. En la región Pampeana se concentra la producción de vacunos, porcinos y equinos. El ovino prevalece en la Patagonia. La producción ganadera como sector importantísimo en la economía argentina, tiene además a procesos fundamentales dentro de la cadena como la refrigeración y procesamiento de carne y subproductos, ya que la producción anual supera los 3,4 millones de toneladas. Desde hace mucho tiempo, Argentina es líder mundial en la exportación de carne cruda, aunque cada vez es más importante la exportación de la carne procesada y envasada. Por este motivo la incorporación de la tecnología es un factor importante a la hora de incrementar las producciones de carne, mediante la utilización del rendimiento expuesto al máximo en sectores como: La nutrición animal. La sanidad animal. La genética e inseminación artificial. El uso de aplicaciones informáticas para la gestión. Las tecnologías para la protección del medio ambiente. Los edificios, equipos y materiales para el ganado. La logística, manipulación y almacenamiento. La estabulación del ganado y el desarrollo de nuevas técnicas de alimentación han contribuido para disminuir la dependencia de las condiciones del medio ambiente. Como principales pautas de manejo que permitien el crecimiento se mencionan técnicas a las que se califica de aplicación sencilla y de alto impacto, como: La implantación de pasturas. La fertilización. La subdivisión de las grandes extensiones en parcelas para un uso más eficiente.

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

7

El adecuado manejo de los rodeos.

Figura 1.4: Ganadería de Corral. Actualmente la ganadería ocupa más de 105 millones de hectáreas, mientras que la agricultura no supera los 25 millones en el territorio nacional. De allí la preocupación por la sustentabilidad de los sistemas. Esto se debe a que en promedio para cada animal se necesita 10 hectáreas para su producción. Además el ganado puede ser criado en áreas donde el duro clima imposibilita el crecimiento de los cultivos, como en las altas montañas o las zonas con una aridez extrema.

1.3.1.

Ganadería Extensiva e Intensiva

Ganadería Extensiva Los sistemas extensivos, tradicionales o convencionales de producción animal se caracterizan esencialmente por formar parte de un ecosistema natural modificado por el hombre, es decir, un agroecosistema, y tienen como objetivo la utilización del territorio de una manera perdurable, o sea, están sometidos a los ciclos naturales, mantienen siempre una relación amplia con la producción vegetal del agroecosistema de que forman parte y tienen la necesidad de

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

8

legar a la generación siguiente los elementos del sistema en un estado igual o superior que los que se recibieron de la generación precedente. Dentro de la ganadería extensiva se puede incluir a la ganadería sostenible que es la ganadería perdurable en el tiempo y que mantiene un nivel de producción sin perjudicar al medio ambiente o al ecosistema. La ganadería sostenible se incluye dentro del concepto de desarrollo sostenible. La explotación ganadera para la alimentación del ganado utiliza los aprovechamientos a diente de los pastos procedentes de prados, pastizales, hierbas y rastrojos; propios, ajenos o comunales, de forma permanente o temporal. Ventajas de la Ganadería Extensiva Requieren un escaso aporte de energía fósil, en ocasiones se requiere 0,1 kilo o menos para obtener 1 kilo de alimento en la mesa del consumidor. Contribuyen a mantener los agroecosistemas de los que forman una parte esencial, manteniendo los agroecosistemas naturales del entorno, como la biodiversidad. En climas áridos o semiáridos contribuyen al mantenimiento de la cubierta vegetal, es decir, evitar la erosión. Prevenir los incendios forestales mediante el control arbustivo, la reducción de biomasa combustible, etc. Inconvenientes de la Ganadería Extensiva Menor eficiencia. No pueden ajustarse fácilmente a la demanda de los consumidores. No pueden proporcionar productos tan homogéneos como solicita la distribución y el mercado de las grandes superficies comerciales. Ganadería Intensiva En la ganadería intensiva el ganado se encuentra estabulado, generalmente bajo condiciones de temperatura, luz y humedad que han sido creadas en forma

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

9

artificial, con el objetivo de incrementar la producción en el menor lapso de tiempo; los animales se alimentan, principalmente, de alimentos enriquecidos. Es por esto que requiere grandes inversiones en aspectos de instalaciones, tecnología, mano de obra y alimento, entre otros. Entre sus ventajas se destaca una elevada productividad, que tiene como contraparte la gran contaminación que genera, mediante la aplicación de múltiples tecnologías y las formas de pensamiento surgidas del capitalismo. Ventajas de la Ganadería Intensiva Eficiencia: La ganadería intensiva obtiene la máxima producción con el dinero invertido en el menor tiempo posible. Adaptación a la demanda del mercado (consumidores). Homogeneidad: Es la obtención de productos homogéneos o de características iguales, para satisfacer las necesidades de la distribución y comercialización a gran escala. Inconvenientes de la Ganadería Intensiva: Gran consumo de energía, generalmente de procedencia energía fósil, en ocasiones hasta 20 kilos por kilo del alimento obtenido. Extremadamente contaminantes, debido a la acumulación de enormes masas de deyecciones, que no pueden ser recicladas en los agrosistemas convencionales y que provocan la contaminación atmosférica, la contaminación del suelo y de las aguas con metales pesados, fármacos etc. Efímero: La ganadería intensiva no es perdurable, es decir, es “insostenible”, que implica que no puede mantenerse indefinidamente en el tiempo.

CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD

10

Figura 1.5: Ganadería Extensiva e Intensiva. El Feed - Lot (engorde a corral), como se observa en la figura 1.5 de la página 10, es uno de los claros ejemplos de esta ganadería ya que obtiene el máximo beneficio, en el menor tiempo posible, concentrando los medios de producción y mecanizando y racionalizando los procesos, para incrementar constantemente el rendimiento productivo, mediante la utilización de la tecnología e infraestructura disponible en el mercado.

Capítulo 2

Conceptos Básicos Sobre el Lenguaje Java
2.1. ¿Qué es Java y Para qué fue Pensado?

Java es un lenguaje de programación sencillo de aprender que originalmente fue desarrollado por un equipo de ingenieros de Sun Microsystems, utilizado por Netscape, por nuevas necesidades, ya que los lenguajes existentes no cumplían con todas las necesidades para el proyecto en marcha. Pero se basaron en lo ya hecho y probado. Es por esta razón que el código Java se expresa en archivos de texto comunes, y tiene una apariencia muy familiar para los programadores de C/C++ y para los programadores en general [2]. Los creadores de Java partieron de la sintaxis de C++ pero “simplificada” y trataron de eliminar todo lo que resulte complicado, o permita fuente de errores. Java nace en un intento de resolver simultáneamente los problemas que se planteaban los desarrolladores de software por la difusión de arquitecturas incompatibles, tanto entre las diferentes máquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma máquina, incrementando la dificultad de crear aplicaciones distribuidas en la Red [2]. El uso del lenguaje Java se destaca en la Web pero sirve para crear todo tipo de aplicaciones (locales, Intranet o Internet). Java sirvió posteriormente 11

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

12

Figura 2.1: Logo de Java. como base para JavaScript, que se detallará más adelante . Una de las utilizaciones más difundida, que justifica a Java como lenguaje es en pequeños electrodomésticos como microondas, tostadoras y, fundamentalmente, televisión interactiva y otros dispositivos electrónicos de uso diario, como celulares, PDA’s, palms y pocket pc.

2.1.1.

Características del Lenguaje Java

Las principales son: Orientado a objetos. Simple. Distribuido. Flexible. Independiente de la plataforma. Robusto. Gestiona la memoria automáticamente.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

13

No permite el uso de técnicas de programación inadecuadas. Multithreading. Cliente-servidor. Mecanismos de seguridad incorporados. Herramientas de documentación incorporadas.

2.1.2.

Desarrollo de las Principales Características de Java

Las principales características que ofrece el lenguaje Java respecto a cualquier otro lenguaje son: Es un lenguaje Orientado a Objetos. Posiblemente el más orientado a objetos de todos los lenguajes existentes; en Java todo, a excepción de los tipos fundamentales de variables (int, char, long), es un objeto. Las plantillas de objetos son llamadas, como en C++, clases y sus copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de memoria. Los objetos se definen en clases, con atributos y métodos, agrupándose en paquetes, y exponiendo interfaces a esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos: encapsulación, herencia y polimorfismo, implementando así la tecnología de objetos de una manera muy completa, y a la vez sencilla y agradable. Se reconocerá al estudiar la semántica, que Java es realmente un lenguaje que merece ser llamado “totalmente orientado a objetos”. Java incorpora funcionalidades inexistentes en C++, como por ejemplo, la resolución dinámica de métodos. En C++ se suele trabajar con librerías dinámicas (DLL’s) que obligan a recompilar la aplicación cuando se retocan las funciones que se encuentran en su interior. Este inconveniente es resuelto por Java mediante una interfaz específica llamada RTTI (RunTime Type Identification) que define la interacción entre objetos excluyendo variables de instancias o implementación de métodos.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

14

Las clases en Java tienen una representación en el runtime que permite a los programadores interrogar por el tipo de clase y enlazar dinámicamente la clase con el resultado de la búsqueda. Es simple. Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y más confusas de éstos. C++ es un lenguaje que padece falta de seguridad, pero C y C++ son lenguajes más difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje. Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles. Java reduce en un 50 % los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos. Es distribuido. Está orientado al trabajo en red, soportando protocolos como TCP/IP, HDP, HTTP y FTP. Por otro lado el uso de estos protocolos es bastante sencillo comparándolo con otros lenguajes que los soportan. Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías de rutinas para acceder e interactuar con protocolos como HTTP y FTP. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales. La verdad es que Java en sí no es distribuido, sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos, es decir, que se corran en varias máquinas. Es robusto. Se refiere a la forma en que está diseñado ya que el compilador de Java detecta muchos errores que otros compiladores sólo detectarían en tiempo de ejecución o incluso nunca. El código generado por el compilador Java es

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

15

independiente de la arquitectura, o sea, puede ejecutarse en un entorno Unix, Mac o Windows. Java no permite el manejo directo del hardware ni de la memoria, así virtualmente es imposible colgar un programa Java. El intérprete siempre tiene el control. Inclusive el compilador es suficientemente inteligente como para no permitir cosas que causen problemas, como usar variables sin inicializarlas, modificar valores de punteros directamente, acceder a métodos o variables en forma incorrecta, utilizar herencia múltiple, etc. Posee herramientas de documentación incorporadas. Además, con el JDK (Java Development Kit) vienen incorporadas muchas herramientas, entre ellas un generador automático de documentación que, con un poco de atención al poner los comentarios en las clases, crea inclusive toda la documentación de las mismas en formato HTML. Es Seguro. Los problemas de virus, o de confidencialidad de los datos aparecen masivamente con Internet, y con la distribución de programas por todas las redes, así el problema de la seguridad ha tomado una nueva dimensión, más grave, ya que actualmente a nuestra máquina pueden llegar aplicaciones hostiles y virus malignos, desde cualquier parte del mundo. Java ha sido adaptado a Internet, pensando mucho en el tema seguridad, sobre todo un tipo de desarrollo: los applets. Java garantiza que ningún applet puede escribir o leer de nuestro disco o mandar información del usuario que accede a la página a través de la red (ej.: e-mail). Un applet Java se ejecuta en un entorno, que impide su intromisión en la máquina cliente. En general no permite realizar cualquier acción que pudiera dañar la máquina o violar la intimidad de quien visita la página Web. Entonces, no hay posibilidad de un virus Java, viajando por toda la red. Java implementa mecanismos de seguridad que limitan el acceso a recursos de las máquinas donde se ejecuta, especialmente en el caso de los Applets (aplicaciones que se cargan desde un servidor y se ejecutan en el cliente). También está diseñado específicamente para trabajar sobre una red, de modo

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

16

que incorpora objetos que permiten acceder a archivos en forma remota (via URL por ejemplo). Es Portable (multiplataforma). En Java no hay aspectos dependientes de la implementación, todas las implementaciones de Java siguen los mismos estándares en cuanto a tamaño y almacenamiento de los datos y corren de igual forma bajo distintas plataformas, mientras que otros lenguajes almacenan datos de formas diferentes según la plataforma en la que se encuentre. Esto no sucede con Java ya que el proceso de compilación no produce código para un procesador en particular, como en los compiladores C/C++, sino que genera código para un procesador ideal, denominado Máquina Virtual Java (Java Virtual Machine, o Java VM). La razón de ésto es la necesidad de poder ejecutarse en cualquier plataforma, sin necesidad de cambiar el código fuente, ni aun de recompilar. Todo programa Java se traduce en una serie de códigos (llamados bytecodes que son el resultado de la compilación de un programa Java) para un procesador imaginario (virtual), el Java VM, que puede ser implementado fácilmente en cualquier plataforma poderosa. Es así como el lenguaje y sus aplicaciones se independizan de la máquina destino, a costa de algo de velocidad, provocada por la necesidad de “simular ” la Java VM, mediante software. Aún los tipos primitivos de datos quedan definidos de un solo paso, para todas las plataformas. Se evitan de esta forma los problemas de portabilidad, conocidos por los programadores de C/C++, al cambiar, por ejemplo, de ambiente a ambiente, el tamaño de los enteros, o el conjunto de caracteres soportados. En Java, esos problemas no existen: sólo existe una máquina virtual. Los programas en Java pueden ejecutarse en cualquiera de las siguientes plataformas, sin necesidad de hacer cambios: Windows/95 y /NT. Power/Mac. Unix (Solaris, Silicon Graphics, ...). La compatibilidad es total:

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

17

A nivel de fuentes: el lenguaje es exactamente el mismo en todas las plataformas. A nivel de bibliotecas: en todas las plataformas están presentes las mismas bibliotecas estándares. A nivel del código compilado: el código intermedio que genera el compilador es el mismo para todas las plataformas. Lo que cambia es el intérprete del código intermedio. Manejo automático de memoria. El lenguaje Java se compone de objetos y estos pueden y deben crearse; tienen una vida corta, ya que se inicia con la ejecución y dura hasta que se termina la ejecución, donde es su destrucción. Mientras que la creación de los objetos se deja bajo la voluntad del programador, la destrucción definitiva de un objeto ocurre cuando no es más referenciado por otros objetos del programa. De esta forma, se elimina una de las causas más comunes de error en otros lenguajes, como la destrucción por el programador de objetos aún en uso en el programa, o la falta de destrucción de objetos que ya son inútiles, ya que no se usan en el resto de la ejecución, pero que molestan con empleo de recursos. Esta técnica de manejo automático de memoria ocupada por los objetos se denominan garbage collection, es como recolección de basura o reciclador de memoria dinámica; gracias a ésto no es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentación de la memoria. El recolector de basuras es un gran aporte a la productividad. Se ha estudiado en casos concretos que los programadores han dedicado un 40 % del tiempo de desarrollo a determinar en qué momento se puede liberar un trozo de memoria. En una aplicación Java hay siempre un proceso, ejecutado como un “thread” o hilo de ejecución separado, que se ocupa de recorrer la memoria donde se encuentran los objetos, y determina cuáles pueden liberarse y destruirse. En Java los programadores ya no necesitan preocuparse de liberar un trozo de memoria cuando no lo necesitan. Es el recolector de basuras el que

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

18

determina cuando se puede liberar la memoria ocupada por un objeto. Java no se aísla y evoluciona. Java trata de ser un lenguaje de producción, no un lenguaje académico o ideal, entonces no intenta comunicarse con librerías de otros lenguajes. Tiene capacidades definidas para implementar clases y métodos (o funciones), escritos, por ejemplo, en C/C++. Esto permite usar lo que ya está hecho, en cada plataforma de implementación. Igualmente, Java es un lenguaje de uso general, y muchas de las rutinas y librerías que se necesita para un proyecto, pueden ser escritas en Java. Debido al éxito del lenguaje, y a su difusión, cada día aparecen nuevas herramientas y paquetes de clases escritas por otros programadores. Dinámico. Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales. Java también simplifica el uso de protocolos nuevos o actualizados. Si el sistema ejecuta una aplicación Java sobre la red y encuentra una pieza (módulo) de la aplicación que no sabe manejar, Java es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para funcionar. Para evitar que los módulos de bytecodes o los objetos o nuevas clases, tengan que ser traídos de la red cada vez que se necesiten, se implementan las opciones de persistencia, para que no se eliminen cuando se limpie la caché de la máquina.

2.1.3.

Ventajas de Java

1. No se vuelve a escribir el código si se quiere ejecutar el programa en otra máquina (multiplataforma). Un solo código funciona para todos los browsers compatibles con Java o donde se tenga una Máquina Virtual de Java (Mac’s, PC’s, Sun’s, etc).

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

19

2. Java es un lenguaje de programación orientado a objetos, y tiene todos los beneficios que ofrece esta metodología de programación.. 3. Un browser compatible con Java deberá ejecutar cualquier programa hecho en Java, esto ahorra a los usuarios tener que estar insertando “plugins” y demás programas que a veces quitan tiempo y espacio en disco. 4. Java es un lenguaje y por lo tanto puede hacer todas las cosas que puede hacer un lenguaje de programación: cálculos matemáticos, procesadores de palabras, bases de datos, aplicaciones gráficas, animaciones, sonido, hojas de cálculo, etc. 5. Si lo que interesa son las páginas Web, no tienen que ser estáticas, porque se les pueden poner toda clase de elementos multimedia, permitiendo un alto nivel de interactividad, sin tener que invertir tanto en paquetes de multimedia.

2.1.4.

Limitaciones con Java

1. Una de las más importantes es la velocidad. Los programas hechos en Java no tienden a ser muy rápidos, pero se está trabajando para mejorar esto. Como los programas de Java son interpretados nunca alcanzan la velocidad de un verdadero ejecutable. 2. Java es un lenguaje de programación. Por tratarse de un lenguaje, debe ser aprendido, lo que es una dificultad para los no programadores. 3. Java es relativamente nuevo. Todavía no se conocen bien todas sus capacidades. Pero en general, Java posee muchas ventajas y mucha fuerza. Con este lenguaje se pueden hacer muchas cosas interesantes. Está de moda en cualquier medio computacional, y se apuesta a futuro con Java.

2.1.5.

Errores con Java

En Java no se pueden cometer algunos errores típicos, ya que: • Java siempre chequea los índices al acceder a un arreglo.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

20

• Java realiza chequeo de tipos durante la compilación (al igual que C). En una asignación entre punteros el compilador verifica que los tipos sean compatibles. • Además, Java realiza chequeo de tipos durante la ejecución (cosa que C y C++ no hacen). Cuando un programa usa un cast para acceder a un objeto como si fuese de un tipo específico, se verifica durante la ejecución que el objeto en cuestión sea compatible con el cast que se le aplica. Si el objeto no es compatible, entonces se levanta una excepción que informa al programador la línea exacta en donde está la fuente del error. • Java posee un recolector de basuras que administra automáticamente la memoria. Es el recolector el que determina cuando se puede liberar el espacio ocupado por un objeto. El programador no puede liberar explícitamente el espacio ocupado por un objeto. • Java no posee aritmética de punteros, porque es una propiedad que no se necesita para programar aplicaciones. En C sólo se necesita la aritmética de punteros para programar malloc/free o para programar el núcleo del sistema operativo. Por lo tanto Java no es un lenguaje para hacer sistemas operativos o administradores de memoria, pero sí es un excelente lenguaje para programar aplicaciones.

2.2.

Existen Distintos Tipos de Java

Según donde se lo aplique se puede distinguir entre:

2.2.1.

JavaScript

Es una versión de Java directamente interpretada, que se incluye como parte de una página HTML, lo que lo hace muy fácil y cómodo para aplicaciones muy pequeñas, pero en realidad tiene muchas limitaciones: No soporta clases ni herencia. No se precompila.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

21

No es obligatorio declarar las variables. Verifica las referencias en tiempo de ejecución. No tiene protección del código, ya que se baja en ASCII. No todos los browsers lo soportan completamente. JavaScript es una forma de trasladar algunas tareas simples al lado del cliente. Y tiene una sintaxis que es en general parecida a la de C, excepto que no hay una función main. Lo que no está dentro de una función se ejecutará mientras se cargue la página. JavaScript recibe información a através de eventos y propiedades de objetos, y la entrega mediante propiedades de objetos y métodos.

2.2.2.

Java Standalone

Son programas Java que se ejecutan directamente mediante el intérprete Java.

2.2.3.

Applets

Son programas Java que corren bajo el entorno de un browser (o del appletviewer, que es el visualizador de applets de Sun.) En sí los applets y Java standalone son el mismo lenguaje, pero cambia un poco la forma en que se implementa el objeto principal (la aplicación). Así los “applets” de una web, son programas diseñados para ser ejecutados en una página Web; pueden ejecutarse en cualquier máquina que se conecte a ella independientemente de qué sistema operativo emplee (siempre que el ordenador en cuestión tenga instalada una JVM (Máquina Virtual de Java)). La definición más extendida de applet, indica que un applet es “una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala automáticamente y se ejecuta en ese lugar como parte de un documento web”. La definición establece el entorno (Internet, Web, etc.). Un applet trata de ser una aplicación pretendidamente corta (no ocupar más de un gigabyte) basadándose en un formato gráfico sin representación

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

22

independiente: es decir, es un elemento a embeber en otras aplicaciones (es un componente en el sentido estricto). Appletviewer: El Visor de Applets de Sun El visualizador de applets (appletviewer) es una aplicación que permite ver en funcionamiento applets, sin necesidad de la utilización de un navegador World-Wide-Web como HotJava, Microsoft Internet Explorer o Netscape. El hecho de que se integre estática (embebido en un ejecutable) o dinámicamente (intérpretes, DLL’s, etc.) no afecta en absoluto a la esencia del comportamiento como componente. Como no existe una base adecuada para soportar aplicaciones industriales Java en las que insertar miniaplicaciones; los applets se han construido mayoritariamente, y con gran acierto comercial, como pequeñas aplicaciones interactivas, con movimiento, luces y sonido... en Internet. Llamadas a Applets con Appletviewer Dado que un applet es una míni aplicación Java diseñada para ejecutarse en un navegador Web, no necesita preocuparse por un método main() ni en dónde se realizan las llamadas. Otra diferencia de Java con el lenguaje C. Es que no hay función main, ya que los applets no lo necesitan. La función main se encuentra “escondida” en el programa que cargó la página html. En los applets no hay una función que sea llamada después de otra, sino que todo gira en torno al tratamiento de los eventos que se produzcan. Es decir que un applet está esperando por una serie de eventos, como la pulsación de una tecla, el movimiento del ratón, o la pulsación de alguna de la teclas del ratón. Y recibido el evento, responder con el método adecuado.El applet asume que el código se está ejecutando desde dentro de un navegador. El appletviewer se asemeja al míni navegador. Espera como argumento el nombre del fichero HTML que debe cargar, no se le puede pasar directamente un programa Java. Este fichero HTML debe contener una marca que especifica el código que cargará el appletviewer.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

23

2.3.

Java en los Browsers de la World Wide Web

Los programas Java son otro recurso más, como pueden ser una página HTML o un archivo gráfico. Al igual que estos últimos viajan desde el servidor a la máquina cliente para ejecutarse en ésta. El lugar más frecuente donde se encuentra el lenguaje Java, es en los exploradores o navegadores (browsers) de Internet. La WWW es la aplicación más popular en Internet, y causante de la explosión de la red de redes. Basa su existencia en dos principales aplicaciones: Los servidores de Web. Son programas dedicados e instalados en las máquinas nodos de la red, que atienden a todos los pedidos de los clientes. Estos solicitan archivos, recursos de la Web, en general, archivos HTML y gráficos. Los archivos HTML son archivos de texto, que contienen una descripción de lo que se ve como página en el browser. La sigla HTML significa Hypertext Markup Languaje (Lenguaje de Marcación de Hipertexto), y es el lenguaje que describe las páginas Web. Los clientes. En las páginas se colocan textos, gráficos y otros recursos. Es trabajo del cliente, el browser, interpretar esa página, mostrándola en pantalla, y reclamando todo lo que se necesite para armarla, como los gráficos y archivos de sonido que la pueden acompañar. En la figura 2.2 de la página 24 se muestra la arquitectura Cliente - Servidor.

2.3.1.

Las Applets en la Web

Al crear algún applet, se exige una construcción, con la marca HTML ‹APPLET...›, que especifica un determinado lugar en una página Web, para que el browser se posicione y ejecute una aplicación Java. Los archivos Java que viajan son de un tipo; al tratarse de archivos con extensión .class, contienen las instrucciones Java ya compiladas y no viajan en código fuente.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

24

Figura 2.2: Arquitectura Cliente - Servidor. Un applet se compone, como mínimo, de un archivo .class, pero puede requerir más archivos .class (con más código para ejecutar), que el browser recupera, o archivos gráficos, de sonido u otros, que el propio applet se encarga de recuperar. Un applet Java no existe por sí mismo (sino dentro de una página .html ), por esto se lo debe invocar desde una página HTML que se haya creado. Seguridad Puede ser riesgoso, por la naturaleza de Internet, traer programas desde un lugar lejano y no controlado a la computadora, para ejecutarlo. Pero los applets Java son seguros ya que Sun y los constructores de browsers han implementado una polí tica de seguridad, que impide a un applet, por ejemplo, leer o escribir en un disco, o interferir con otras aplicaciones en ejecución. Es tan grande la seguridad que, puede llegar a molestar a algunos programadores, que en un applet nunca se pueda grabar un archivo local, con datos

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

25

transitorios o de configuración. Restricción de Seguridad de Java No se pueden cargar archivos que estén en una máquina distinta a aquella desde la cual se cargó el applet. El applet se ejecuta en el cliente, e intenta acceder a un archivo local. Eso provoca una excepción (que, por supuesto, puede detectarse con un catch y tratarse). Por razones de seguridad, los applets son más limitados que las aplicaciones Java locales. Las políticas de seguridad las manejan los browsers (no Java), y generalmente los límites que se imponen a los applets son: Un applet no puede cargar bibliotecas (libraries) ni definir métodos nativos. No puede leer o escribir normalmente archivos en el cliente que lo carga desde otro server. No puede establecer conexiones de red, salvo al servidor del que proviene. No puede arrancar programas en la máquina donde se está ejecutando. No puede leer algunas propiedades del sistema. En las ventanas de los applets se indica que se trata de un applet. Pero también, pueden: Reproducir sonidos. Establecer conexiones con el servidor del que provienen. Llamar fácilmente páginas HTML desde el browser. Invocar métodos públicos de otros applets de la misma página. Seguir corriendo aunque se cambie de página en el browser. Si se cargan desde la máquina local no tienen ninguna de las restricciones anteriores.

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

26

Figura 2.3: Bytecode y JVM. En realidad, la especificación de Java permite que los applets lean archivos en otras máquinas dando la URL completa; sin embargo, los browsers no lo permiten.

2.3.2.

Máquinas Virtuales

El lenguaje Java se compila, no para una plataforma o procesador en particular, sino produciendo código (que se denomina bytecodes), destinado a ser interpretado por la llamada Máquina Virtual Java. En la figura 2.3 de la página 26 se puede apreciar como trabaja.

Esta máquina no es única, sino que hay una por cada plataforma y, en realidad, cada browser que implementa Java tiene la suya. Así, el Microsoft Explorer usará una máquina propia en Windows, mientras que el Netscape Navigator usará otra máquina, que variará de Windows a UNIX. Todas tienen la misma funcionalidad (o deberían). Tanto el usuario como los programadores no deberían preocuparse por las distintas implementaciones. Sin embargo, hay quejas de los desarrolladores, originadas en las pequeñas

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

27

diferencias que se encuentran tanto entre una implementación y otra, como en el aspecto de la interface gráfica. Además de la máquina virtual, cada browser instala una serie de clases, listas para usar, que Java espera tener disponibles en cualquier plataforma. Esas clases tienen una funcionalidad definida, que no debería sufrir modificaciones. Netscape y Microsoft La empresa Netscape, creadora del Netscape Navigator, soporta Java desde la versión 2 del browser. Pero Microsoft no se quedó atrás y soporta Java desde la versión 2.0 de su browser Internet Explorer. Ambos browsers instalan y usan una máquina virtual propia Java. No hay diferencias apreciables en las prestaciones de estos dos browsers, respecto de Java.

Figura 2.4: Netscape Navigator - Internet Explorer. Entre Netscape (en múltiples plataformas) y Microsoft (en plataformas Windows) acaparan casi la totalidad del mercado de los browsers. En general, los browsers, de cualquier origen, soportan Java en ambientes que permiten la multitarea y los llamados múltiples hilos de ejecución (multithreading). Para poder explotar al máximo el potencial de Java se requiere de un sistema operativo multithreading (como Unix, Windows, OS/2), porque Java es un lenguaje interpretado y al compilar un programa Java, lo que se genera es un seudocódigo definido por Sun, para una máquina genérica. Al ejecutar posteriormente sobre una máquina en particular, el software de ejecución Java simplemente interpreta las instrucciones, emulando a dicha

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

28

Figura 2.5: JIT - Just In Time. máquina genérica. Claro que esto no es muy eficiente, entonces Netscape como Hotjava o Explorer, al ejecutar el código por primera vez, lo van compilando (mediante un JIT: Just In Time Compiler), así al crear el código ya está compilado específicamente para la máquina huésped. El lenguaje de esa máquina genérica es público, y si uno quisiera hacer un intérprete Java para otro sistema operativo sólo tendría que implementarlo y pedir a Sun la aprobación (que verifique que cumpla con los requisitos de Java en interpretación de cada instrucción, seguridad y otros).

2.3.3.

Java sin Browsers

No todo es Internet en Java. Este es un lenguaje de uso general, que sólo incidentalmente cobró popularidad en Internet. Se puede desarrollar aplicaciones Java que se ejecuten en una máquina propia, sin necesidad de estar conectados a la red, y sin el auxilio de browsers. Mientras los programas Java para Internet y páginas HTML se llaman “applets”, los que pueden ejecutarse fuera de la red se llaman genéricamente

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

29

“aplicaciones”.

2.3.4.

HotJava

HotJava, es un navegador con soporte Java (Java-enabled), desarrollado en Java. Como cualquier navegador de Web, HotJava puede decodificar HTML estándar y URL’s estándares, aunque no soporta completamente el estándar HTML 3.0. La ventaja sobre el resto de navegadores, sin soporte Java, es que puede ejecutar programas Java sobre la red. La diferencia con Netscape es que tiene implementados completamente los sistemas de seguridad que propone Java, esto significa que puede escribir y leer en el disco local, aunque esto hace disminuir la seguridad, ya que se pueden grabar en el disco programas que contengan código malicioso o introducir un virus, por ejemplo. No obstante, el utilizar esta característica de HotJava es decisión del usuario.

Figura 2.6: HotJava.

2.4.

Java en Hebras - Threads

La traducción literal de thread es hilo o hebra. Los threads (a veces llamados, procesos ligeros), son básicamente pequeños procesos o piezas independientes de un gran proceso. Pero el concepto de threads en los ambientes y sistemas operativos es relativamente complejo de explicar: independiente-

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

30

mente del sistema elegido, se puede pensar que un thread es algo así como el lugar de ejecución de un programa. Java es multithreading: esto significa que tiene capacidad de “diálogo”, y permite ejecutar muchas actividades simultáneas en un programa, es decir, threads en paralelo como si fuera una conversación múltiple y simultánea. No hay que confundir multithreading con la capacidad de ejecutar varios programas a la vez. Esta es una posibilidad, pero también un mismo programa puede utilizar varios threads (caminos de ejecución) simultáneamente y depende fundamentalmente de la capacidad del sistema operativo para soportar multithreading. Por esto Java no puede ejecutarse (al menos en forma completa) en sistemas que no lo soporten. Como los threads son construídos con el lenguaje Java, son más fáciles de usar y más robustos que sus semejantes en C o C++. El uso de threads nos permite, por ejemplo, ejecutar simultáneamente varios programas que interactúen entre ellos; o, también, que un programa, mientras por ejemplo actualiza la pantalla, simultáneamente realice una serie de cálculos sin tener que hacer esperar el usuario. Una forma sencilla de verlo es imaginar que se tiene un grupo de microprocesadores que pueden ejecutar, cada uno, un solo thread; y se asignan programas (o partes de programas) a cada uno de ellos. Además, se puede imaginar que los microprocesadores comparten una memoria común y recursos comunes, de lo que surgirá una serie de problemas importantes a tener en cuenta cuando se usan threads.

2.4.1.

La Ventaja de ser Multi-Threaded

Consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo que lo soporte como Unix, Windows u otros, aún así supera tanto en facilidad de desarrollo como en rendimiento, a los entornos de flujo único de programa (single-threaded), que todavía se utilizan en la mayoría de los programas; es decir un programa comienza y su ejecución sigue un camino único: es un solo thread, como si fuera un “monólogo”. Los pasos básicos a seguir para usar threads en un programa son tres:

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

31

Figura 2.7: Clase Thread. La clase que se quiere asignar a un thread debe implementar la interface Runnable. Se debe crear una variable (instancia) del tipo Thread, que permita acceder y manejar el thread. Y crear un método run() que es el que ejecuta el código del programa propiamente dicho. Al utilizar la tecnología de navegación concurrente, se sabe lo frustrante que puede ser esperar que se traiga una gran imagen. En Java, las imágenes se pueden traer en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador.

2.5.

Java Para Aplicaciones Corporativas

Java e Intranet actualmente son palabras de moda. Y Java particularmente es una buena tecnología para desarrollar aplicaciones corporativas, ya que en donde la red sea algo crítico, Java facilita tremendamente la vida de la programación corporativa. Las más grandes compañías se han convencido de que la Red Corporativa es la Empresa. Ya que la Red es un canal importante por donde fluye la información que mantiene vivo el negocio. La información fluye desde el gran

CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA

32

servidor de las oficinas centrales, hasta los servidores de las delegaciones, las estaciones de trabajo de los programadores y las PC’s. Si esta red no se mantiene, los pedidos no llegan, el inventario no se actualiza, el software no se desarrolla adecuadamente, los clientes no están satisfechos y, fundamentalmente, el dinero no entra. La necesidad de diagnosticar y reducir los problemas que puedan surgir en la red, hace que se esté incorporando continuamente nuevas metodologías que subsanen este grave problema. Java es el lenguaje apto para Internet; pero, para las aplicaciones corporativas, allí donde la red es el punto crítico, sería una buena tecnología, si se compararan las capacidades de Java con la lista de necesidades de la red corporativa. Aplicaciones Efectivas o Eficientes Las aplicaciones que se crean en grandes empresas deben ser más efectivas que eficientes; es decir, conseguir que el programa funcione y el trabajo salga adelante es más importante que el hacerlo eficientemente. Esto es una realidad de la programación corporativa. Java al ser un lenguaje más simple que cualquiera de los que ahora están de moda para los programadores, permite concentrarse en la mecánica de la aplicación, en vez de pasarse horas y horas incorporando API’s “Interface de Programación de Aplicaciones” para el control de las ventanas, controlando minuciosamente la memoria, sincronizando los ficheros de cabecera y corrigiendo los mensajes del linker. Java tiene su propio toolkit para interfaces, maneja por sí mismo la memoria que utilice la aplicación, no permite ficheros de cabecera separados (en aplicaciones puramente Java) y solamente usa enlace dinámico. Muchas de las implementaciones de Java actuales son puros intérpretes. Los bytecodes son interpretados por el sistema run-time de Java, la Máquina Virtual Java (JVM ), sobre el ordenador del usuario. Hay proveedores que ofrecen compiladores nativos Just-In-Time (JIT ). Si la Máquina Virtual Java dispone de un compilador instalado, las secciones (clases) del bytecode de la aplicación se compilarán hacia la arquitectura nativa

del ordenador del usuario. Los programas Java competirán con el rendimiento de programas en C++. Los compiladores JIT no se utilizan en la forma tradicional de un compilador; los programadores no compilan y distribuyen binarios Java a los usuarios. La compilación JIT tiene lugar a partir del bytecode Java, en el sistema del usuario, como una parte (opcional) del entorno run-time local de Java. Java permite algunas técnicas innovadoras de optimización. Como se mencionó anteriormente, Java es inherentemente multithreaded, a la vez que ofrece posibilidades de multithread como la clase Thread y mecanismos muy sencillos de usar de sincronización; Java en sí utiliza threads. Los desarrolladores de compiladores inteligentes pueden utilizar esta característica de Java para lanzar un thread que compruebe la forma en que se está utilizando la aplicación. Más específicamente, este thread podría detectar qué métodos de una clase se están usando con más frecuencia e invocar a sucesivos niveles de optimización en tiempo de ejecución de la aplicación. Cuanto más tiempo esté corriendo la aplicación o el applet, los métodos estarán cada vez más optimizados. Si un compilador JIT está embebido en el entorno run-time de Java, el programador no se preocupa de hacer que la aplicación se ejecute óptimamente. Mantenimiento y Soporte Uno de los problemas más conocidos que ocurre con el software corporativo es la demanda de mantenimiento y realimentación. Java no es, ciertamente, la solución para el problema del mantenimiento, pero es un lenguaje que posee varias características que harán la vida más fácil a los desarrolladores y mantenedores de aplicaciones. [2]

Capítulo 3

El Lenguaje Java
3.1. Introducción a su Codificación

Java por ser un lenguaje orientado a objetos, posee ciertas características que hoy día se consideran estándares en los lenguajes OO, para esto se utilizarán los siguientes conceptos: Objetos. Clases. Métodos. Subclases. Herencia simple. Enlace dinámico. Encapsulamiento.

34

CAPÍTULO 3. EL LENGUAJE JAVA

35

Para programar orientado a objetos es necesario primero diseñar un conjunto de clases. La claridad, eficiencia y mantenibilidad del programa resultante dependerá principalmente de la calidad del diseño de clases. Un buen diseño de clases significará una gran economía en tiempo de desarrollo y mantenimiento. Lamentablemente se necesita mucha habilidad y experiencia para lograr diseños de clases de calidad. Un mal diseño de clases puede llevar a programas OO de peor calidad y de más alto costo que el programa equivalente no OO [2, Castillo-Cobo-Solares]. La gran ventaja de un lenguaje OO son las bibliotecas de clases que se pueden construir para la aplicación. Una biblioteca de clases cumple el mismo objetivo de una biblioteca de procedimientos en una lenguaje como C. Una biblioteca de clases es mucho más fácil de usar que una biblioteca de procedimientos, incluso para programadores sin experiencia en orientación a objetos. Esto se debe a que las clases ofrecen mecanismos de abstracción más eficaces que los procedimientos. Se puede distinguir entre varios tipos de programadores en Java: • El diseñador de clases: Es el encargado de definir qué clases ofrece una biblioteca y cuál es la funcionalidad que se espera de estas clases. La persona tiene que ser muy hábil y de mucha experiencia. Un diseño equivocado puede conducir a clases que son incomprensibles para los clientes de la biblioteca. • El programador de clases de biblioteca: Es el encargado de programar las clases especificadas por el diseñador de clases. La persona debe entender orientación a objetos, pero no requiere mayor experiencia en diseño de clases.

CAPÍTULO 3. EL LENGUAJE JAVA

36

• El cliente de bibliotecas: Es el programador de aplicaciones, sólamente utiliza las clases que otros han diseñado y programado. Como en el caso anterior necesita entender orientación a objetos y conocer la biblioteca que va a usar, pero no necesita mayor experiencia. Tanto programadores de clases como clientes de bibliotecas pueden llegar a convertirse en buenos diseñadores de clases en la medida que adquieran experiencia, comparando los diseños de las bibliotecas que utilicen. Por lo tanto es importante destacar que no se necesita gran experiencia en diseño orientado a objetos para poder aprovechar las ventajas de la orientación a objetos.

3.1.1.

Bibliotecas de Clases Estándares de Java

Toda implementación de Java debe tener las siguientes bibliotecas de clases: Manejo de archivos. Comunicación de datos. Acceso a la red Internet. Acceso a bases de datos. Interfaces gráficas. La interfaz de programación de estas clases es estándar, es decir en todas ellas las operaciones se invocan con el mismo nombre y los mismos argumentos.

3.2.

Estructura General de un Programa Java

La estructura habitual de un programa realizado en cualquier lenguaje orientado a objetos u OOP (Object Oriented Programming) tiene muchas particularidades, principalmente en el lenguaje Java. En el siguiente ejemplo de código se presenta la estructura general de un programa en Java:

CAPÍTULO 3. EL LENGUAJE JAVA

37

import java.awt.*; import java.lang.String; import java.lang.Integer; import java.awt.event.WindowEvent; import java.util.*; import java.awt.TextField; public class Simula extends Frame implements ActionListener,ItemListener{ MenuBar barra; m1 =new Menu(“Archivo”); barra.add(m1); m2 =new Menu(“Ver”); barra.add(m2); .... public static void main(String argv [ ]){ Simula menus = new Simula(); menus.setTitle(“Simulación de Redes”); menus.setVisible(true); } }

Aparece una clase que contiene el programa principal Simula (aquel que contiene la función main()) y algunas clases de usuario (las específicas de la aplicación que se está desarrollando) que son utilizadas por el programa principal. La aplicación se ejecuta por medio del nombre de la clase que contiene la función main(). Las clases de Java se agrupan en packages, que son librerías de clases. Si las clases no se definen como pertenecientes a un package, se utiliza un package por defecto (default) que es el directorio activo.

CAPÍTULO 3. EL LENGUAJE JAVA

38

3.3.
3.3.1.

Conceptos Básicos
Clase

Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos. A esos datos y funciones pertenecientes a una clase se les denomina variables y métodos o funciones miembro. La programación orientada a objetos se basa en la programación de clases. Un programa se construye a partir de un conjunto de clases. Una vez definida e implementada una clase, es posible declarar elementos de esta clase de modo similar a como se declaran las variables del lenguaje (int, double, String). Los elementos declarados de una clase se denominan objetos de la clase. De una única clase se pueden declarar o crear numerosos objetos. La clase es lo genérico: es el patrón o modelo para crear objetos. Cada objeto tiene sus propias copias de las variables miembro, con sus propios valores, en general distintos de los demás objetos de la clase. Las clases pueden tener variables static, que son propias de la clase y no de cada objeto. Ejemplo:

public abstract class FuncionActivacion implements Cloneable,Serializable{ /*constructor sin argumentos que permite la herencia */ public FuncionActivacion () { } }

3.3.2.

Herencia

La herencia permite que se puedan definir nuevas clases basadas en clases existentes, lo cual facilita reutilizar código previamente desarrollado. Si una clase deriva de otra (extends) hereda todas sus variables y métodos. La clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados.

CAPÍTULO 3. EL LENGUAJE JAVA

39

Figura 3.1: Herencia en Java. En Java, a diferencia de otros lenguajes orientados a objetos, una clase sólo puede derivar de una única clase, con lo cual no es posible realizar herencia múltiple en base a clases. Sin embargo es posible “simular” la herencia múltiple en base a las interfaces.

3.3.3.

Interface

Una interface es un conjunto de declaraciones de funciones. Si una clase implementa (implements) una interface, debe definir todas las funciones especificadas por la interface. Una clase puede implementar más de una interface, representando una forma alternativa de la herencia múltiple. Una interface puede derivar de otra o incluso de varias interfaces, en cuyo caso incorpora todos los métodos de las interfaces de las que deriva. Ejemplo: La clase TangenteHiperbólica se extiende de la clase FunciónActivación que implementa la interface Serializable.
/*función de activación tangente hiperbólica */

CAPÍTULO 3. EL LENGUAJE JAVA

40

public class TangenteHiperbolica extends FuncionActivacion implements Serializable{ /*constructor sin argumentos */ public TangenteHiperbolica () { } }

3.3.4.

Package

Un package es una agrupación de clases. Existen una serie de packages incluidos en el lenguaje. Además el programador puede crear sus propios packages. Todas las clases que formen parte de un package deben estar en el mismo directorio. Los packages se utilizan con las siguientes finalidades: 1. Para agrupar clases relacionadas. 2. Para evitar conflictos de nombres. En caso de conflicto de nombres entre clases importadas, el compilador obliga a cualificar en el código los nombres de dichas clases con el nombre del package. 3. Para ayudar en el control de la accesibilidad de clases y miembros. Por estas razones, durante la etapa de Diseño del Software a desarrollar, se tiene que crear tantos paquetes como sea necesario, como en el siguiente ejemplo donde se utiliza la sentencia package.

package myprojects.simula; import myprojects.calculos.*; import myprojects.interfase.*;

CAPÍTULO 3. EL LENGUAJE JAVA

41

Figura 3.2: Típicos Packages Predefinidos.

3.3.5.

La Jerarquía de Clases de Java (API)

Durante la generación de código en Java, es recomendable y casi necesario tener siempre a la vista la documentación on-line del API de Java. En dicha documentación es posible ver tanto la jerarquía de clases, es decir la relación de herencia entre clases, como la información de los distintos packages que componen las librerías base de Java. Es importante distinguir entre lo que significa herencia y package. Un package es una agrupación arbitraria de clases, una forma de organizar las clases. La herencia sin embargo consiste en crear nuevas clases en base a otras ya existentes. Las clases incluidas en un package no derivan en general de la misma clase. En la documentación on-line se presentan ambas visiones: “Package Index” y “Class Hierarchy”. La primera presenta la estructura del API de Java agrupada por packages, mientras que en la segunda aparece la jerarquía de clases. Hay que resaltar el hecho de que todas las clases en Java son derivadas de la clase java.lang.Object, por lo que heredan todos los métodos y variables de ésta. Si se selecciona una clase en particular, la documentación muestra una descripción detallada de todos los métodos y variables de la clase. A su vez muestra su herencia completa (partiendo de la clase java.lang.Object).

CAPÍTULO 3. EL LENGUAJE JAVA

42

Figura 3.3: API de Java.

3.3.6.

Variables Dentro del Lenguaje Java

Una variable en Java es un identificador que representa una palabra de memoria que contiene información. El tipo de información almacenado en una variable sólo puede ser del tipo con que se declaró esa variable. En Java hay dos tipos principales de variables: 1. Variables de tipos primitivos. Están definidas mediante un valor único y almacenan directamente ese valor siempre que pertenezca al rango de ese tipo. Por ejemplo una variable int almacena un valor entero como 1, 2, 0, -1, etc. Esto significa que al asignar una variable entera a otra variable entera, se copia el valor de la primera en el espacio que ocupa la segunda variable. 2. Variables referencia. Las variables referencia son referencias o nombres de una información más compleja: arrays u objetos de una determinada clase. Una referencia a un objeto es la dirección de un área en memoria destinada a representar ese objeto. El área de memoria se solicita con el operador new. Al asignar una variable de tipo referencia a objeto a otra variable se asigna la dirección y no el objeto referenciado por esa dirección. Esto significa que ambas variables quedan referenciando el mismo objeto. En Java una variable no puede almacenar directamente un objeto, como ocurre en C y C++. Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere decir en realidad es que la variable es una referencia a un string.

CAPÍTULO 3. EL LENGUAJE JAVA

43

Desde el punto de vista de su papel dentro del programa, las variables pueden ser: 1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método; pueden ser tipos primitivos o referencias. 2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al finalizar dicho bloque. Pueden ser también tipos primitivos o referencias. En la Tabla 3.1 de la pág. 43 se muestra una declaración, el nombre de la variable introducida y el tipo de información que almacena la variable: Declaración int i; String s; int a []; int[]b; Identificador i s a b Tipo entero referencia a string referencia a arreglo de enteros referencia a arreglo de enteros

Cuadro 3.1: Tipos de Variables. En la Tabla 3.2 de la pág. 43 se muestran las dos grandes categorías de tipos para las variables en Java: Tipos Primitivos int, short, byte, long char, boolean float, double Referencias a Objetos Strings Arreglos otros objetos

Cuadro 3.2: Categorías de Variables. En la Tabla 3.3de la pág. 44 se indica para cada tipo primitivo el número de bits que se emplea en su representación y el rango de valores que se puede almacenar en las variables de estos tipos. Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto de B. Esto quiere decir que las variables de tipo B siempre se pueden

CAPÍTULO 3. EL LENGUAJE JAVA

44

Tipo int short byte long boolean char float double

Bits 32 16 8 64 1 16 32 64

Rango −231 ..231 − 1 −215 .,215 − 1 −27 .,27 − 1 −263 .,263 − 1 n/a n/a IEEE IEEE

Ejemplos 0,1,5,-120,... 0,1,5,-120,... 0,1,5,-120,... 0,1,5,-120,... false, true ‘a’,‘A’,‘0’,‘*’,... 1.2 1.2

Cuadro 3.3: Tipos Primitivos de Variables. asignar a variables de tipo A (eventualmente con pérdida de significancia). Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double es de mayor rango que float.

3.3.7.

Visibilidad y Vida de las Variables

Se entiende por visibilidad o ámbito de una variable a la parte de la aplicación donde dicha variable es accesible y por lo tanto puede ser utilizada en cualquier expresión. En Java todos las variables deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de cualquier método) son válidas mientras existe el objeto de la clase. Las variables miembro de una clase declaradas como public son accesibles a través de una referencia a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen

CAPÍTULO 3. EL LENGUAJE JAVA

45

acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen acceso a todas las variables miembro de A declaradas como public o protected, pero no a las declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y funciones miembro de su clase base declaradas como public o protected. Otra característica del lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta será preciso utilizar el operador this. Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la cual son creados y eliminados los objetos. La forma de crear nuevos objetos es utilizar el operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta de por cuántas variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior significa que aunque una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias apuntando a ese mismo objeto.

3.4.

Operadores en Java

Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente a continuación.

3.4.1.

Operadores Aritméticos

Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (* ), división (/ ) y resto de la división ( % ).

CAPÍTULO 3. EL LENGUAJE JAVA

46

3.4.2.

Operadores de Asignación

Los operadores de asignación permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es:
variable = expression;

Java dispone de otros operadores de asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones “acumulativas” sobre una variable. La siguiente Tabla 3.4 de la pág. 46, muestra estos operadores y su equivalencia con el uso del operador igual (=). Operador += -= =* =/ %= Utilización op1 + = op2 op1 - = op2 op1 * = op2 op1 / = op2 op1 % = op2 ExpresiónEquivalente op1 = op1 + op2 op1 = op1 - op2 op1 = op1 * op2 op1 = op1 / op2 op1 = op1 % op2

Cuadro 3.4: Operadores de Asignación.

3.4.3.

Operadores Unarios

Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores.

3.4.4.

Operadores Incrementales

Java dispone del operador incremento (++) y decremento (—). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que (—) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas:

CAPÍTULO 3. EL LENGUAJE JAVA

47

1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece. 2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa. En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más complicada, el resultado de utilizar estos operadores en una u otra de sus formas será indiferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos operadores.

3.4.5.

Operadores Relacionales

Los operadores relacionales sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operadores es siempre un valor boolean (true o false) según se cumpla o no la relación considerada. La siguiente Tabla 3.5 de la pág. 47 muestra los operadores relacionales de Java. Operador > >= < <= == != Utilización op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2 El resultado es true si op1 es mayor que op2 si op1 es mayor o igual que op2 si op1 es menor que op 2 si op1 es menor o igual que op2 si op1 y op2 son iguales sio p1 y op2 son diferentes

Cuadro 3.5: Operadores Relacionales. Estos operadores se utilizan con mucha frecuencia en las bifurcaciones y en los bucles, que se verán luego.

CAPÍTULO 3. EL LENGUAJE JAVA

48

Ejemplo de Operadores Incrementales y Operadores Relacionales en un método.

public void cambiarParesEntrenamiento(double[ ] paresEntrenamiento){ /* inicialización de sus valores a partir de los valores pasados como argumentos */ for(int i = 0; i< paresEntrenamiento.length; i++) {for(int j = 0; j< numeroNeuronasEntrada; j++) {entradaEntrenamiento[i][j] = paresEntrenamiento[i][j]; } for(int j = 0; j< numeroSalidas; j++) {salidaEntrenamiento[i][j] = paresEntrenamiento[i] [j+numeroNeuronasEntrada]; } } }

3.4.6.

Operador de Concatenación de Cadenas de Caracteres (+)

El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con un rótulo puede utilizarse la sentencia:

editor.append(“Error Obtenido:” + String.valueOf(imprimoError) + “\n”); editor.append(“Iteraciones:”+ String.valueOf(imprimoIteraciones) + “\n”); editor.append(“Inicio: ” + horaInicial.toString() + “\n”);

CAPÍTULO 3. EL LENGUAJE JAVA

49

editor.append(“Final: ” + horaFinal.toString() + “\n”);

donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir. Las variables imprimoErrror, imprimoIteraciones, horaInicial, horaFinal son convertidas en cadena de caracteres para poder concatenarlas.

3.4.7.

Precedencia de Operadores

El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La Tabla 3.6 de la pág. 49 muestra el orden en que se ejecutan los distintos operadores en una sentencia, de mayor a menor precedencia: Nombre Postfijos Unarios De creación Multiplicativo Adición Shift Relacional Igualdad AND Or Excluyente Or Incluyente Logico AND Logico OR Condicional Asignación Sintáxis [ ] .(params) expr++ expr++expr —expr +expr -expr ! (type) expr * /% +<< >> >>> <> <= >= instanceof == != & ^ | && || ?: = += -= *= /= %= &= ^= |= <<= >>= >>>=

Cuadro 3.6: Precedencia de Operadores. En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de

CAPÍTULO 3. EL LENGUAJE JAVA

50

derecha a izquierda, lo que significa que el valor de la izquierda se copia sobre la variable de la derecha.

3.5.

Estructuras de Programación

Las estructuras de programación o estructuras de control permiten tomar decisiones y realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. En la mayoría de los lenguajes de programación, este tipo de estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de un lenguaje a otro. La sintaxis de Java coincide prácticamente con la utilizada en C/C++, lo que hace que para un programador de C/C++ no suponga ninguna dificultad adicional.

3.5.1.

Sentencias o Expresiones

Una expresión es un conjunto variables unidos por operadores. Son órdenes que se le dan al computador para que realice una tarea determinada. Una sentencia es una expresión que acaba en punto y coma (;). Se permite incluir varias sentencias en una línea, aunque lo habitual es utilizar una línea para cada sentencia. A continuación se muestra un ejemplo de una línea compuesta de tres sentencias:
i = 0; j = 5; x = i + j;

3.5.2.

Comentarios

Existen varias formas diferentes de introducir comentarios entre el código de Java. Son similares a la forma de realizar comentarios en el lenguaje C/C++. Los comentarios son útiles para poder entender el código utilizado, facilitando de ese modo futuras revisiones y correcciones. Además permite que cualquier persona distinta al programador original pueda comprender el código escrito de una forma más rápida. Java interpreta que todo lo que aparece a la derecha de dos barras “// ” en una línea cualquiera del código es un comentario del programador y no lo tiene en cuenta. El comentario puede empezar al comienzo de la línea o a

CAPÍTULO 3. EL LENGUAJE JAVA

51

continuación de una instrucción que debe ser ejecutada. Otra forma de incluir comentarios consiste en escribir el texto entre los símbolos “ /* */ ”. Este segundo método es válido para comentar más de una línea de código. Por ejemplo:

// Esta línea es un comentario int a=1; // Comentario a la derecha de una sentencia // Esta es la forma de comentar más de una línea utilizando // las dos barras. Requiere incluir dos barras al comienzo de cada línea /* Otra forma es mucho más cómoda para comentar un número elevado de líneas ya que sólo requiere modificar el comienzo y el final. */

En Java existe además otra forma especial de introducir los comentarios (utilizando /***/ más algunos caracteres especiales) que permite generar automáticamente la documentación sobre las clases y packages desarrollados por el programador. Una vez introducidos los comentarios, el programa javadoc.exe (incluido en el JDK) genera de forma automática la información de forma similar a la presentada en la propia documentación del JDK. Comentarios Iniciales Todos los ficheros fuente deben comenzar con un comentario al estilo C que indique el programador, o programadores, la fecha, una nota de copyright y una pequeña descripción del propósito del programa. Por ejemplo:
/* * Nombre de la clase * Versión * Copyright */

CAPÍTULO 3. EL LENGUAJE JAVA

52

3.5.3.

Sentencia import

La palabra import indica que son declaraciones que le avisan al compilador que el programa usará. En el caso de java.applet.* todas las clases que pertenecen al paquete (packages) applet (por eso el applet.* . El que produce que se usen todas las clases es el “*”. En el caso de java.awt. Graphics indica que se usará el objeto Graphics del paquete awt. Por ejemplo:
import java.applet.*; import java.awt.Graphics;

3.5.4.

Longitud de Líneas

Se deben evitar líneas de más de 80 caracteres, porque sino no son manejadas correctamente por muchos terminales y herramientas. Los ejemplos de uso en la documentación deben ir en líneas más cortas, generalmente de no más de 70 caracteres.

3.5.5.

Bifurcaciones

Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor de una expresión lógica o relacional. Se tratan de estructuras muy importantes ya que son las encargadas de controlar el flujo de ejecución de un programa. Existen dos variantes del tipo if. Bifurcación if Esta estructura permite ejecutar un conjunto de sentencias en función del valor que tenga la expresión de comparación. Ejemplo: se ejecuta si la expresión de comparación (error < errorMinimo) tiene valor true:

CAPÍTULO 3. EL LENGUAJE JAVA

53

protected void comprobarNuevoMinimo() { if (error < errorMinimo) {errorMinimo = error; vectorDisMinimo = (double[ ])(vectorDis.clone()); } /* fin del if */ }

Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y no son necesarias si sólo hay una sentencia dentro del if. Bifurcación if else Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas en el else se ejecutan en el caso de no cumplirse la expresión de comparación (false), Ejemplo:
public double decirSalidaActual(int indiceEtapa) { if(pila != null) {return pila[indiceEtapa];} else {System.out.println(“Fallo: Pila no creada”); return 0; } }

3.5.6.

Bucles

Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina también lazo o loop. El código incluido entre las llaves {} (opcionales si el proceso repetitivo consta de una sola línea), se ejecutará mientras se cumpla unas determinadas condiciones. Hay que prestar especial atención a los bucles

CAPÍTULO 3. EL LENGUAJE JAVA

54

infinitos, hecho que ocurre cuando la condición de finalizar el bucle (booleanExpression) no se llega a cumplir nunca. Se trata de un fallo muy típico, habitual sobre todo entre programadores poco experimentados. Bucle while En el siguiente ejemplo se muestra que se ejecutará la sentencia fin++ mientras la expresión (capas.charAt(fin)!=‘,’ && capas.charAt(fin)!=-1) sea verdadera.
for (int j=0; j < numeroCapas; j++) {int fin = principio; try { while (capas.charAt(fin) != ‘,’ && capas.charAt(fin) != -1) {fin++; } } }

Bucle for A continuación se podrá apreciar la utilización del bucle for:
/* calcular el nuevo vector de diseño */ for (int i = 0; i < vectorDis.length; i++) {vectorDis[i] = vectorDis[i] + learningRate * S[i]; }

La sentencia int i = 0 (inicialización) se ejecuta al comienzo del for, e i++ (incremento) después de vectorDis[i] = vectorDis[i] + learningRate * S[i] (sentencia). La expresión booleana (vectorDis.length) se evalúa al comienzo de cada iteración; el bucle termina cuando la expresión de comparación toma el valor false.

CAPÍTULO 3. EL LENGUAJE JAVA

55

Bucle do while Es similar al bucle while pero con la particularidad de que el control está al final del bucle (lo que hace que el bucle se ejecute al menos una vez, independientemente de que la condición se cumpla o no). Una vez ejecutados las sentencias, se evalúa la condición: si resulta true se vuelven a ejecutar las sentencias incluidas en el bucle, mientras que si la condición se evalúa a false finaliza el bucle.

do{ /* calcular el gradiente del vector fijar el vector de diseño */ problema.fijoVector(vectorDis); /* incrementar el contador de iteraciones*/ step++; } while (error > errorDeseado && step < iteracionesMaximas); /* ... hasta que el error sea menor o igual que el deseado o */ /* se alcance el número de iteraciones pasado como argumento */ problema.fijoVector(vectorDis);

Sentencia return Una forma de salir de un bucle es utilizar la sentencia return. Esta sentencia sale también de un método o de una función. En el caso de que la función devuelva alguna variable, este valor se deberá poner a continuación del return.A continuación se muestra como sale de un método:

public double devuelveErrorMinimo() {return errorMinimo; }

CAPÍTULO 3. EL LENGUAJE JAVA

56

Bloque try{...} catch{...} finally{...} Java incorpora en el propio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente sólo los errores de sintaxis son detectados en esta operación. El resto de problemas surgen durante la ejecución de los programas. Exception En el lenguaje Java, una Exception es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la ejecución del programa. En este caso conviene terminar ordenadamente y dar un mensaje explicando el tipo de error que se ha producido. Otras excepciones, como por ejemplo no encontrar un fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error (dando por ejemplo un nuevo path del fichero no encontrado). Los errores se representan mediante clases derivadas de la clase Throwable, pero los que tiene que chequear un programador derivan de Exception (java.lang.Exception que a su vez deriva de Throwable). Existen algunos tipos de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el uso de bloques try, catch y finally. El código dentro del bloque try está “vigilado”: Si se produce una situación anormal y se lanza como consecuencia una excepción, el control pasa al bloque catch que se hace cargo de la situación y decide lo que hay que hacer. Se pueden incluir tantos bloques catch como se desee, cada uno de los cuales tratará un tipo de excepción. Finalmente, si está presente, se ejecuta el bloque finally, que es opcional, pero que en caso de existir se ejecuta siempre, sea cual sea el tipo de error. En el caso en que el código de un método pueda generar una Exception y no se desee incluir en dicho método la gestión del error (es decir los bucles try/catch correspondientes), es necesario que el método pase la Exception al método desde el que ha sido llamado. Esto se consigue mediante la adición de la palabra throws seguida del nombre de la Exception concreta, después de la lista de argumentos del método. A su vez el método superior deberá incluir los bloques try/catch o volver a pasar la Exception. De esta forma se puede ir

CAPÍTULO 3. EL LENGUAJE JAVA

57

pasando la Exception de un método a otro hasta llegar al último método del programa, el método main().

3.6.

Clases en Java

Las clases son el centro de la Programación Orientada a Objetos (OOP - Object Oriented Programming). Algunos conceptos importantes de la POO son los siguientes: 1. Encapsulación: Las clases pueden ser declaradas como públicas (public) y como package (accesibles sólo para otras clases del package). Las variables miembro y los métodos pueden ser public, private, protected y package. De esta forma se puede controlar el acceso y evitar un uso inadecuado. 2. Herencia: Una clase puede derivar de otra (extends), y en ese caso hereda todas sus variables y métodos. Una clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados. 3. Polimorfismo: Los objetos de distintas clases pertenecientes a una misma jerarquía o que implementan una misma interface pueden tratarse de una forma general e individualizada, al mismo tiempo. Esto facilita la programación y el mantenimiento del código.

3.6.1.

Características Importantes de las Clases

A continuación se enumeran algunas características importantes de las clases: 1. Todas las variables y funciones de Java deben pertenecer a una clase. No hay variables y funciones globales. 2. Si una clase deriva de otra (extends), hereda todas sus variables y métodos. 3. Java tiene una jerarquía de clases estándar de la que pueden derivar las clases que crean los usuarios.

CAPÍTULO 3. EL LENGUAJE JAVA

58

4. Una clase sólo puede heredar de una única clase (en Java no hay herencia múltiple). Si al definir una clase no se especifica de qué clase deriva, por defecto la clase deriva de Object. La clase Object es la base de toda la jerarquía de clases de Java. 5. En un fichero se pueden definir varias clases, pero en un fichero no puede haber más que una clase public. Este fichero se debe llamar como la clase public que contiene con extensión *.java. Con algunas excepciones, lo habitual es escribir una sola clase por fichero. 6. Si una clase contenida en un fichero no es public, no es necesario que el fichero se llame como la clase. 7. Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se aplican por medio de la referencia this. 8. Las clases se pueden agrupar en packages, introduciendo una línea al comienzo del fichero (package packageName;). Esta agrupación en packages está relacionada con la jerarquía de directorios y ficheros en la que se guardan las clases.

3.6.2.

Métodos o Funciones Miembros

Métodos de Objeto Los métodos son funciones definidas dentro de una clase. Salvo los métodos static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implícito. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis, a continuación del nombre del método. La primera línea de la definición de un método se llama declaración o header; el código comprendido entre las llaves {} es el cuerpo o body del método. Considérese el siguiente ejemplo:
imprimoError=algor.devuelveErrorMinimo(); public double devuelveErrorMinimo() {return errorMinimo; }

CAPÍTULO 3. EL LENGUAJE JAVA

59

La Clase Object Como ya se ha dicho, la clase Object es la raíz de toda la jerarquía de clases de Java. Todas las clases de Java derivan de Object. La clase Object tiene métodos interesantes para cualquier objeto que son heredados por cualquier clase. Entre ellos se pueden citar los siguientes: 1. Métodos que pueden ser redefinidos por el programador: clone(): Crea un objeto a partir de otro objeto de la misma clase. El método original heredado de Object lanza una CloneNotSupportedException. Si se desea poder clonar una clase hay que implementar la interface Cloneable y redefinir el método clone(). Este método debe hacer una copia miembro a miembro del objeto original. No debería llamar al operador new ni a los constructores. equals(): Indica si dos objetos son o no iguales. Devuelve true si son iguales, tanto si son referencias al mismo objeto como si son objetos distintos con iguales valores de las variables miembro. toString(): Devuelve un String que contiene una representación del objeto como cadena de caracteres, por ejemplo para imprimirlo o exportarlo. finalize(): Este método ya se ha visto al hablar de los finalizadores. 2. Métodos que no pueden ser redefinidos (son métodos final): getClass(): Devuelve un objeto de la clase Class, al cual se le pueden aplicar métodos para determinar el nombre de la clase, su superclase, las interfaces implementadas, etc. Se puede crear un objeto de la misma clase que otro sin saber de qué clase es. notify(), notifyAll() y wait(): Son métodos relacionados con los threads (hilos).

CAPÍTULO 3. EL LENGUAJE JAVA

60

3.7.
3.7.1.

Clases de Mayor Utilidad
Clase Arrays

Los arrays de Java (vectores, matrices, hiper-matrices de más de dos dimensiones) se tratan como objetos de una clase predefinida. Los arrays son objetos, pero con algunas características propias. Los arrays pueden ser asignados a objetos de la clase Object y los métodos de Object pueden ser utilizados con arrays. Algunas de las características más importantes de los arrays son las siguientes: 1. Los arrays se crean con el operador new seguido del tipo y número de elementos. 2. Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo, vect.length). 3. Se accede a los elementos de un array con los corchetes [ ] y un índice que varía de 0 a length-1. 4. Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new. 5. Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero para valores numéricos, la cadena vacía para Strings, false para boolean, null para referencias). 6. Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia. 7. Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método). Inicialización de Arrays Los arrays se pueden inicializar con valores entre llaves {...} separados por comas. También los arrays de objetos se pueden inicializar con varias llamadas a new dentro de unas llaves {...}.

CAPÍTULO 3. EL LENGUAJE JAVA

61

Si se igualan dos referencias a un array no se copia el array, sino que se tiene un array con dos nombres, apuntando al mismo y único objeto. Ejemplo de creación de una referencia a un array:

/*vector de pesos */ public double[ ] pesos;

También existen arrays bidimensionales, que se crean de un modo muy similar al de C++ (con reserva dinámica de memoria). En Java una matriz es un vector de vectores fila, o más en concreto un vector de referencias a los vectores fila. Con este esquema, cada fila podría tener un número de elementos diferente. Una matriz se puede crear directamente en la siguiente forma:

/*vector de las entradas de los pares de entrenamiento*/ protected double[ ][ ] entradaEntrenamiento;

3.7.2.

Clases String y StringBuffer

Las clases String y StringBuffer están orientadas a manejar cadenas de caracteres. La clase String está orientada a manejar cadenas de caracteres constantes, es decir, que no pueden cambiar. La clase StringBuffer permite que el programador cambie la cadena insertando, borrando, etc. La primera es más eficiente, mientras que la segunda permite más posibilidades. Ambas clases pertenecen al package java.lang, y por lo tanto no hay que importarlas. Hay que indicar que el operador de concatenación (+) entre objetos de tipo String utiliza internamente objetos de la clase StringBuffer y el método append(). Los métodos de String se pueden utilizar directamente sobre literals (cadenas entre comillas), como por ejemplo: “Hola”.length().

CAPÍTULO 3. EL LENGUAJE JAVA

62

Métodos de la Clase String Algunos métodos de String y la función que realizan: String(...): Constructores para crear Strings a partir de arrays de bytes o de caracteres. String(String str) yString(StringBuffer sb): Costructores a partir de un objeto String o StringBuffer. charAt(int): Devuelve el carácter en la posición especificada. getChars(int, int, char[ ], int): Copia los caracteres indicados en la posición indicada de un array de caracteres. length(): Devuelve el número de caracteres de la cadena. toLowerCase(): Convierte en minúsculas (puede tener en cuenta el locale). toUpperCase(): Convierte en mayúsculas (puede tener en cuenta el locale). valueOf(): Devuelve la representación como String de sus argumento. Admite Object, arrays de caracteres y los tipos primitivos.

3.7.3.

Clase Double

La clase java.lang.Double deriva de Number, que a su vez deriva de Object. Esta clase contiene un valor primitivo de tipo double. Algunos Métodos de la Clase Double Double(double) y Double(String): Los constructores de esta clase. doubleValue(), floatValue(), longValue(), intValue(), shortValue(), byteValue(): Métodos para obtener el valor del tipo primitivo. String toString(), Double valueOf(String): Conversores con la clase String. isInfinite(), isNaN(): Métodos de chequear condiciones. equals(Object): Compara con otro objeto.

CAPÍTULO 3. EL LENGUAJE JAVA

63

3.7.4.

Clase Integer

La clase java.lang.Integer tiene como variable miembro un valor de tipo int. Algunos Métodos de la Clase Integer Integer(int) y Integer(String): Constructores de la clase. doubleValue(), floatValue(), longValue(),intValue(), shortValue(), byteValue(): Conversores con otros tipos primitivos. Integer decode(String), Integer parseInt(String), String toString(), Integer ValueOf(String): Conversores con String del sistema a partir del nombre de dicha propiedad.

3.8.
3.8.1.

El AWT (Abstract Windows Toolkit)
Qué es el AWT

El AWT (Abstract Windows Toolkit) es la parte de Java que se ocupa de construir interfaces gráficas de usuario. Aunque el AWT ha estado presente en Java desde la versión 1.0, la versión 1.1 representó un cambio notable, sobre todo en lo que respecta al modelo de eventos. La versión 1.2 ha incorporado un modelo distinto de componentes llamado Swing, que también está disponible en la versión 1.1 como package adicional.

3.8.2.

Creación de una Interface Gráfica de Usuario

Para construir una interface gráfica de usuario hace falta: 1. Un “contenedor” o container : Es la ventana o parte de la ventana donde se situarán los componentes (botones, barras de desplazamiento, etc.) y donde se realizarán los dibujos. Se correspondería con un formulario o una picture box de Visual Basic.

CAPÍTULO 3. EL LENGUAJE JAVA

64

2. Los componentes: Son menúes, botones de comando, barras de desplazamiento, cajas y áreas de texto, botones de opción y selección, etc. Se corresponderían con los controles de Visual Basic. 3. El modelo de eventos: El usuario controla la aplicación actuando sobre los componentes, de ordinario con el ratón o con el teclado. Cada vez que el usuario realiza una determinada acción, se produce el evento correspondiente, que el sistema operativo transmite al AWT. El AWT crea un objeto de una determinada clase de evento, derivada de AWT Event. Este evento es transmitido a un determinado método para que lo gestione. En Visual Basic el entorno de desarrollo crea automáticamente el procedimiento que va a gestionar el evento (uniendo el nombre del control con el tipo del evento mediante el carácter) y el usuario no tiene más que introducir el código. En Java es un poco más complicado, ya que el componente u objeto que recibe el evento debe “registrar” o indicar previamente el objeto que se va a hacer cargo de gestionar ese evento.

3.8.3.

Objetos “event source” y Objetos “event listener”

El modelo de eventos de Java está basado en que los objetos sobre los que se producen los eventos (event sources) “registran” los objetos que habrán de gestionarlos (event listeners), para lo cual los event listeners habrán de disponer de los métodos adecuados. Estos métodos se llamarán automáticamente cuando se produzca el evento. La forma de garantizar que los event listeners disponen de los métodos apropiados para gestionar los eventos es obligarlos a implementar una determinada interface Listener. Las interfaces Listener se corresponden con los tipos de eventos que se pueden producir. Las capacidades gráficas del AWT resultan pobres y complicadas en comparación con lo que se puede conseguir con Visual Basic, pero tienen la ventaja de poder ser ejecutadas casi en cualquier ordenador y con cualquier sistema operativo.

CAPÍTULO 3. EL LENGUAJE JAVA

65

3.8.4.

Proceso a Seguir Para Crear Una Aplicación Interactiva (Orientada a Eventos)

Pasos que se pueden seguir para construir una aplicación orientada a eventos sencilla, con interface gráfica de usuario: 1. Determinar los componentes que van a constituir la interface del usuario, como botones, cajas de texto, menúes, etc. 2. Crear una clase para la aplicación que contenga la función main(). 3. Crear una clase Ventana, sub-clase de Frame, que responda al evento WindowClosing(). 4. La función main() deberá crear un objeto de la clase Ventana (en el que se van a introducir las componentes seleccionadas) y mostrarla por pantalla con el tamaño y posición adecuados. 5. Añadir al objeto Ventana todos los componentes y menúes que deba contener. 6. Definir los objetos Listener (objetos que se ocuparán de responder a los eventos, cuyas clases implementan las distintas interfaces Listener) para cada uno de los eventos que deban estar soportados. En aplicaciones pequeñas, el propio objeto Ventana se puede ocupar de responder a los eventos de sus componentes. En programas más grandes se puede crear uno o más objetos de clases especiales para ocuparse de los eventos. 7. Finalmente, se deben implementar los métodos de las interfaces Listener que se vayan a hacer cargo de la gestión de los eventos.

3.9.

Errores más Frecuentes en la Programación con Java

A continuación se presenta una varios ejemplos de errores, vistos desde el punto de vista de la portabilidad, porque quizá el sine qua non de Java, en última instancia sea perseguir una verdadera independencia de plataforma. Los errores no tienen ningún orden de dificultad, no son más que algunos de ellos en los que puede caer cualquier programador.

CAPÍTULO 3. EL LENGUAJE JAVA

66

Hay muchísimas formas cometer fallos a la hora de programar en Java; algunas se deben simplemente a malos hábitos y son muy difíciles de encontrar, mientras que otros saltan a la vista al instante. Los errores de programación más obvios, también son los que con más frecuencia cometen los programadores. Quizás muchos de los fallos se evitarían si los programadores intentarán aplicar calidad a sus programas desde el momento mismo de concebir el programa, y no la tendencia de aplicar pureza a la aplicación en el último momento.

3.9.1.

Scheduling de Hilos de Ejecución

El scheduling de los hilos de ejecución, es decir, el tiempo que el sistema destina a la ejecución de cada uno de los hilos de ejecución, puede ser distinto en diferentes plataformas. Si no se tienen en cuenta las prioridades o se deja al azar la prevención de que dos hilos de ejecución accedan a un mismo objeto al mismo tiempo, el programa no será portable. El siguiente programa, por ejemplo, no es portable:
class Contador implements Runnable { static long valor = 0; public void run() { valor += 1; } public static void main( String args[] ) { try { Thread hilo1 = new Thread( new Contador() ); hilo1.setPriority( 1 );

CAPÍTULO 3. EL LENGUAJE JAVA

67

Thread hilo2 = new Thread( new Contador() ); hilo2.setPriority( 2 ); hilo1.start(); hilo2.start(); hilo1.join(); hilo2.join(); Systtem.out.println( valor ); } catch( Exception e ) { e.printStackTrace(); } } }

Este programa puede no imprimir “2” en todas las plataformas, porque los dos hilos de ejecución no están sincronizados y, desgraciadamente, este es un problema muy profundo y no hay forma de detectar su presencia ni adivinar el momento en que va a ocurrir. Una solución simple, y drástica, es hacer todos los métodos sincronizados. Pero esto también tiene problemas porque puede presentar como puntos sin retorno obvios, lo que en realidad es una corrupción de datos. El scheduling de los hilos de ejecución es uno de los aspectos más problemáticos de la programación Java, porque la naturaleza del problema se vuelve global, al intervenir varios hilos de ejecución. No se puede buscar el problema en una parte del programa, es imprescindible entender y tratar el programa en su globalidad. Además, hay ejemplos de contención de hilos que no serán detectados. Por ejemplo, en la clase Contador anterior no se detectará el problema ya que la contención está en el acceso al campo, en lugar de en el acceso al método.

3.9.2.

Errores en el Uso de las Características de Portabilidad de Java

Hay características de portabilidad en el API de Java. Es posible, pero menos portable, escribir código que no haga uso de estas características. Muchas

CAPÍTULO 3. EL LENGUAJE JAVA

68

de las propiedades del sistema proporcionan información sobre la portabilidad; por ejemplo, se pueden utilizar las propiedades del sistema para conocer cuál es el carácter definido como fin de línea o el que se emplea como terminador del archivo, para emplear el adecuado a la plataforma en que se está ejecutando el programa. Java proporciona dos métodos para facilitar la escritura de programas portables en este sentido. Por un lado, utilizar el método println() en vez de imprimir las cadenas seguidas del terminador de cadena embebido; o también, utilizar la expresión System.getProperty(“line.separator”) para conocer cuál es el terminado de línea que se utiliza en la plataforma en que se está ejecutando el programa. En general, el uso de las propiedades facilita en gran modo la portabilidad y debería extenderse su uso siempre que fuese aplicable.

3.9.3.

Uso de Directorios Definidos

Un error muy común y fácil de cometer entre los programadores, aunque igual de fácil de corregir es la designación en el código de nombre de los archivos, que pueden dar lugar a problemas de portabilidad, pero cuando se añade el directorio en que se sitúan, seguro que estos problemas aparecerán. Estos fallos son más comunes entre programadores con viejos hábitos, que eran dependientes del sistema operativo, y que son difíciles de olvidar. La forma más portable de construir un File para un fichero en un directorio es utilizar el constructor File(File,String). Otra forma sería utilizar las propiedades para conocer cuál es el separador de ficheros y el directorio inicial; o también, preguntarle al operador a través de una caja de diálogo. Otro problema es la noción de camino absoluto, que es dependiente del sistema. En Unix los caminos absolutos empiezan por /, mientras que en Windows pueden empezar por cualquier letra. Por esta razón, el uso de caminos absolutos que no sean dependientes de una entrada por operador o de la consulta de las propiedades del sistema no será portable. El ejemplo siguiente proporciona una clase útil para la construcción de nombres de archivos. La última versión del JDK es mucho más exhaustiva, y detecta más fácilmente los errores cometidos en los directorios y nombres de

CAPÍTULO 3. EL LENGUAJE JAVA

69

ficheros.
import java.io.File; import java.util.StringTokenizer; public class UtilFichero { /* Crea un nuevo fichero con el nombre de otros. Si la base inicial es * nula, parte del directorio actual */ public static File dirInicial( File base,String path[] ) { File valor = base; int i=0; if( valor == null && path.length == 0 ) { valor = new File( path[i++] ); } for( ; i < path.length; i++ ) { valor = new File( valor,path[i] ); } return( valor ); } public static File desdeOrigen( String path[] ) { return( dirInicial( null,path ) ); }

public static File desdeProp( String nombrePropiedad ) { String pd = System.getProperty( nombrePropiedad );

CAPÍTULO 3. EL LENGUAJE JAVA

70

return( new File( pd ) ); } // Utilizando la propiedad del sistema “user.dir” public static File userDir() { return( desdeProp( “user.dir” ) ); } // Utilizando la propiedad del sistema “java.home” public static File javaHome() { return( desdeProp( “java.home” ) ); } // Utilizando la propiedad del sistema “user.home” public static File userHome() { return( desdeProp( “user.home” ) ); } /* Separa el primer argumento, utilizando el segundo argumetno como * carácter separador. * Es muy útil a la hora de crear caminos de ficheros portables */ public static String[] split( String p,String sep ) { StringTokenizer st = new StringTokenizer( p,sep ); String valor[] = new String[st.countTokens()];

CAPÍTULO 3. EL LENGUAJE JAVA

71

Figura 3.4: JDBC en Java.
for( int i=0; i < valor.length; i++ ) { valor[i] = st.nextToken(); } return( valor ); } }

3.9.4.

Carga de Drivers JDBC

El interfaz JDBC, definido por el paquete java.sql, proporciona gran flexibilidad a la hora de codificar la carga del driver JDBC a utilizar. Esta flexibilidad permite la sustitución de diferentes drivers sin que haya que modificar el código, a través de la clase DriverManager, que selecciona entre los drivers disponibles en el momento de establecer la conexión. Los drivers se pueden poner a disposición de DriverManager a través de la propiedad del sistema jdbc.drivers o cargándolos explícitamente usando el método java.lang.Class.forName().

CAPÍTULO 3. EL LENGUAJE JAVA

72

También es posible la carga de una selección de drivers, dejando que el mecanismo de selección de DriverManager encuentre el adecuado en el momento de establecer la conexión con la base de datos. Hay que tener siempre en cuenta los siguientes puntos: La prueba de drivers se intenta siempre en el orden en que se han registrado, por lo que los primeros drivers tienen prioridad sobre los últimos cargados, con la máxima prioridad para los drivers listados en jdbc.drivers. Un driver que incluya código nativo fallará al cargarlo sobre cualquier plataforma diferente de la que fue diseñado; por lo que el programa deberá recoger la excepción ClassNotFoundException. Un driver con código nativo no debe registrarse con DriverManager hasta que no se sepa que la carga ha tenido éxito. Un driver con código nativo no está protegido por la caja negra de Java, así que puede presentar potenciales problemas de seguridad.

3.9.5.

Terminación de Líneas

Las distintas plataformas de sistemas operativos tienen distintas convenciones para la terminación de líneas en un fichero de texto. Por esto debería utilizarse el método println(), o la propiedad del sistema line.separator, para la salida; y para la entrada utilizar los métodos readLine(). Java internamente utiliza Unicode, que al ser un estándar internacional, soluciona el problema a la hora de codificar; pero el problema persiste al leer o escribir texto en un archivo. En el JDK 1.1 se utilizan las clases java.io.Reader y java.io.Writer para manejar la conversión del set de caracteres, pero el problema puede surgir cuando se leen o escriben archivos ASCII planos, porque en el ASCII estándar no hay un carácter específico para la terminación de líneas; algunas máquinas utilizan \n, otras usan \r, y otras emplean la secuencia \r\n. Enarbolando la bandera de la portabilidad, deberían utilizarse los métodos println() para escribir una línea de texto, o colocar un marcador de fin de línea.

También, usar el método readLine() de la clase java.io.BufferedReader para recoger una línea completa de texto. Los otros métodos readLine() son igualmente útiles, pero el de la clase BufferedReader proporciona al código también la traslación.

3.9.6.

Entrada/Salida por Archivo

Las clases de entrada y salida del JDK 1.0 no son portables a plataformas que no soporten formatos nativos de archivos no-ASCII. Es fácil para el programador suponer alegremente que todo el mundo es ASCII. Pero la realidad no es esa, los chinos y los japoneses, por ejemplo, no puedes escribir nada con los caracteres ASCII. Hay que tener esto en cuenta si se quiere que los programas viajen fuera del país propio.

3.9.7.

Fuentes de Caracteres

El tamaño y disponibilidad de varios tipos de fuentes varía de pantalla a pantalla, incluso en una misma plataforma hardware, dependiendo de la instalación que se haya hecho. Esto es algo que no descalifica totalmente el programa, porque se verá defectuosamente, pero el programa podrá seguir usándose; pero debería prevenirse, porque se presupone que el programador desea que su software aparezca de la mejor manera posible en cualquier plataforma. El modo mejor de evitar todo esto es no codificar directamente el tamaño de los textos, dejar que los textos asuman su tamaño en relación al layout, y utilizar los métodos de la clase FontMetrics para encontrar el tamaño en que aparecen los caracteres de una cadena sobre un Canvas. Cuando se coloca una fuente que no se encuentra entre las de defecto, hay que asegurarse siempre de colocar alguna de respaldo en el bloque catch. Cuando se crea un menú para seleccionar fuentes de caracteres, se debería utilizar el método java.awt.Toolkit.getFontList(), en lugar de especificar una lista de fuentes. Cuando se actualice un programa del JDK 1.0 al JDK 1.1, hay que tener en cuenta que los nombre de las fuentes de caracteres se han actualizado, tal como se indica en la documentación del método getFontList().

Capítulo 4

Los Servlets

4.1.

Servlets

Los servlets son programas de Java que construyen respuestas dinámicas para el cliente, tal como páginas Web. Los servlets reciben y responden a las demandas de los clientes Web, normalmente por HTTP. Los servlets son más eficientes que los programas (CGI) porque son cargados de una sola vez en la memoria, y cada demanda es manejada por un hilo 74

CAPÍTULO 4. LOS SERVLETS

75

de la máquina virtual de Java, no por el sistema operativo. Además los servlets son escalables, dando soporte para una multi-aplicación de configuración del servidor. [2, IBM Press] Permiten utilizar datos caché, acceso a información de base de datos, y compartir datos con otro servlets, archivos JSP y (en algunos ambientes) con los bean empresariales.

4.1.1.

Principios de Codificación de Servlet

Para crear un servlet de HTTP, es necesario extender las clases: javax.servlet.HttpServlet y sustituir cualquier método que se desee implementar en el servlet. Por ejemplo, un servlet reemplaza el método doGet para manejar las demandas Get de los clientes. El HttpServletRequest representa los requerimientos de un cliente. Este objeto da acceso al servlet, a la información incluida como datos en formato HTML, encabezados HTTP, etc. El HttpServletResponse representa la respuesta del servlet. El servlet usa este objeto para devolverle datos al cliente como errores de HTTP (200, 404, y otros), encabezados de respuesta (Content-Type, SetCookie, y otros), y datos de salida para escribir cadenas de salida de respuesta o salida impresa. El principio de un servlet podría parecerse al siguiente ejemplo:
import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import java.util.*; public class MyServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{

CAPÍTULO 4. LOS SERVLETS

76

4.1.2.

Ciclo de Vida del Servlet

Las clases javax.servlet.http.HttpServlet definen métodos tales como: Iniciar un servlet. Solicitar servicios. Quitar un servlet del servidor. Éstos son conocidos como métodos del ciclo de vida y son llamados en la siguiente secuencia: Se construye el servlet. Se inicializa con el método INIT. Se manejan llamadas de los clientes al método de servicio. Se saca el servlet de servicio. Se destruye con el método destruir. Se finaliza el servlet y la basura es recolectada. En la figura 5.1 de la página 89 se puede apreciar gráficamente el Ciclo de Vida de un Servlet.

4.1.3.

Instanciación e Inicialización

El motor del servlet (la función del Servidor de Aplicaciones que procesa servlets, archivos JSP, y otros tipos de server-side incluyendo codificación) crea una instancia del servlet. El motor del servlet crea el objeto de configuración del servlet y lo usa para pasar los parámetros de inicialización del servlet al método INIT. La inicialización de los parámetros persiste hasta que el servlet se destruye y es aplicada a todas las invocaciones de ese servlet hasta destruirse. Si la inicialización tiene éxito, el servlet está disponible para el servicio. Si la inicialización falla, el motor del servlet descarga el servlet. El administrador

CAPÍTULO 4. LOS SERVLETS

77

Figura 4.1: Ciclo de Vida de un Servlet.

CAPÍTULO 4. LOS SERVLETS

78

puede inhabilitar una aplicación y el servlet para el servicio. En tales casos, la aplicación y el servlet permanecen inhabilitados hasta que el administrador los habilite.

4.1.4.

Servicio de Demanda

Una demanda del cliente llega al servidor de aplicaciones. El motor del servlet crea un objeto demanda y un objeto respuesta. El motor del servlet invoca al método de servicio del servlet, procesa el requerimiento y usa métodos del objeto respuesta para crear la respuesta para el cliente. El método de servicio recibe información sobre el requerimiento del objeto demanda, procesa el requerimiento, y usa los métodos del objeto respuesta para crear la contestación para el cliente. El método de servicio puede invocar otros métodos para procesar el requerimiento, tales como doGet (), doPost (), o métodos del usuario.

4.1.5.

Terminación

El motor del servlet invoca al método destroy () del servlet cuando apropia y descarga el servlet. La Máquina Virtual de Java realiza la recolección de basura después de la destrucción del servlet. Cuando el contenedor Web ya no necesita que el servlet o una nueva instancia del servlet se recarguen, invoca al método destroy () del servlet. El contenedor Web también puede llamar al método destroy () si el motor necesita conservar recursos o una llamada pendiente a un método service () del servlet excediendo el timeout. La Máquina Virtual de Java realiza recolección de basura después del destroy.

4.1.6.

Modelos de Acceso JSP

Se puede acceder a los archivos JSP de dos maneras: El browser envía un requerimiento para los archivos JSP. Los archivos JSP acceden a los beans u otros componentes que generan contenido dinámico para ser enviado al browser como se muestra en la figura

CAPÍTULO 4. LOS SERVLETS

79

Figura 4.2: Requerimiento de un Archivo JSP. 4.2 de la página 79. Cuando el servidor Web recibe un requerimiento para un archivo JSP, el servidor envía ese requerimiento al servidor de aplicaciones. El servidor de aplicaciones analiza el archivo JSP y genera código fuente de Java que se compila y se ejecuta como un servlet. El requerimiento se envía a un servlet que genera contenido dinámico y llama a un archivo JSP para enviar el contenido a un browser, como se muestra en la figura 4.3 de la página 80. Este modelo de acceso facilita la generación de contenido separado del despliegue de contenido. El servidor de aplicaciones proporciona un juego de métodos en el objeto HttpServiceRequest object y el objeto HttpServiceResponse. Estos métodos permiten una invocación de servlet para colocar un objeto (normalmente un bean) en un objeto demanda y pasa ese requerimiento a otra página (normalmente un archivo JSP) para el despliegue. La página invocada recupera el beans del objeto demanda y genera el HTML que recibe el cliente.

4.1.7.

Procesadores JSP

Cada procesador de JSP es un servlet que se puede adherir a una aplicación Web para manejar todos los requerimientos JSP pertenecientes a la misma. Cuando se instala el Application Server en un servidor Web, la configuración del servidor Web pasa los requerimientos HTTP para los archivos JSP

CAPÍTULO 4. LOS SERVLETS

80

Figura 4.3: Requerimiento de un Servlet. (archivos con la extensión .jsp) al Application Server. El procesador de JSP crea y compila un servlet desde cada archivo JSP. El procesador produce estos archivos para cada JSP: Archivos Java que contienen el código del lenguaje Java para el servlet. Archivos de clase que se compilan en el servlet. El procesador de JSP pone los archivos .java, y .class en un camino específico al procesador. Los archivos .java y .class tienen el mismo nombre de archivos. El procesador usa una convención de denominación que incluye el agregado de subrayado de los caracteres y un sufijo para el nombre del archivo JSP. Por ejemplo, si el nombre del archivo JSP es simple.jsp, los archivos generados son: _simple_xjsp.java y _simple_xjsp.class. Como todos los servlets, un servlet generado desde un archivo JSP se extiende desde javax.servlet.http.HttpServlet. El código Java de servlet contiene

CAPÍTULO 4. LOS SERVLETS

81

declaraciones de importación para las clases necesarias y una declaración de paquete, si la clase del servlet es parte de un paquete. Si el archivo JSP contiene sintaxis de JSP (como directivas y scriptlets), el procesador de JSP convierte la sintaxis de JSP al código Java equivalente. Si el archivo JSP contiene etiquetas HTML, el procesador agrega el código Java a fin de que el servlet realice la salida de HTML carácter por carácter.

4.1.8.

Compilación Batch de Archivos JSP

WebSphere Application Server proporciona un compilador batch de JSP. Al usar la función del compilador batch de archivos JSP, se habilitan respuestas más rápidas al requerimiento inicial del cliente para los archivos JSP en el servidor Web de producción. El compilador batch ahorra recursos del sistema y proporciona seguridad en el servidor de aplicaciones, especificando cuándo el servidor está chequeando un archivo de clase o recompilando un archivo JSP. El servidor de aplicaciones supervisará la compilación de los archivos JSP para cambios, y automáticamente compilará y recargará los archivos JSP, siempre que el servidor de aplicaciones descubra que el archivo JSP ha cambiado. Modificando este proceso, se puede ahorrar tiempo y recursos consumidos por las compilaciones y asegurar que se tenga el control de la compilación de los archivos JSP. También es útil como una manera rápida al sincronizar todos los archivos JSP para una aplicación.

4.1.9.

Desarrollando Aplicaciones

Para WebSphere Application Server, las aplicaciones son combinaciones de bloques que trabajan conjuntamente para el logro de una función de la lógica comercial. Las aplicaciones Web son grupos de uno o más servlets, más el contenido estático. Aplicaciones Web = servlets + archivos JSP + archivos XML + archivos HTML + gráficos. El modelo de programación de WebSphere Application Server está basado en la plataforma Java de Sun (J2SE). El ambiente J2SE soporta la base para construir redes centrales de aplicaciones empresariales para correr sobre una

CAPÍTULO 4. LOS SERVLETS

82

variedad de sistemas. El software J2SE consiste en los Java SDK Standard Edition y el Java Runtime Environment (JRE) Standard Edition.

4.1.10.

Fases de Inicialización y de Terminación

Un motor del servlet crea una instancia de un servlet en los siguientes momentos: Automáticamente en el arranque de la aplicación, si esa opción se configura para el servlet. En la primera demanda del cliente para el servlet después del arranque de la aplicación. Cuando el servlet se vuelve a cargar. El método INIT ejecuta sólo una vez durante la vida del servlet. Ejecuta cuando el motor del servlet carga el servlet. Con el Application Server se puede configurar el servlet para ser cargado cuando comienza la aplicación o cuando un cliente accede por primera vez al servlet. El método INIT no se repite a menos que muchos clientes accedan al servlet. El método destroy () ejecuta sólo una vez durante la vida del servlet. Eso pasa cuando el motor del servlet detiene el servlet. Típicamente, se detienen servlets como parte del proceso de detener la aplicación.

4.1.11.

Rasgos de Java Servlet API

Algunos puntos de interés del Java Servlet API son: Un despachador de requerimientos asociado a cada recurso (servlet). Un despachador de requerimientos de recursos que pueden procesar demandas HTTP (como servlets y archivos JSP) y los archivos relacionados a esos recursos (como HTML estático y GIFs). El motor del servlet genera un solo despachado de requerimiento por cada servlet o JSP cuando se produce una instanciación. El despachador recibe el pedido del cliente y despacha la demanda al recurso.

CAPÍTULO 4. LOS SERVLETS

83

Un contexto del servlet para la aplicación.

4.1.12.

Patrones y Guías de Servlets/JSP

A continuación se proporcionan las pautas específicas sobre cómo organizar una aplicación que usa servlets y JSP’s. Patrones Servlet/JSP. Con este modelo es posible organizar una aplicación Web en el servlets y JavaServer Pages de manera tal que es fácil de mantener el código. Motivación. Para aplicaciones que requieren modelado complejo sobre el nodo del servidor de aplicación Web, no es fácil definir la granularidad de servlets y cómo interactúan los servlets. Pero sin un buen diseño para el servlets y JSP es difícil mantener la aplicación. Además en la fase del análisis de un proyecto, usa casos y diagramas de transición de estados ampliamente usados para describir el resultado de la fase del análisis. Podría ser útil trazar esos resultados en el diseño e implementación de la fase. En un caso se puede contemplar el servlet como el evento central y procesa todas las demandas del cliente. Ejecuta la acción necesaria para ese evento y envía el requerimiento a uno (de muchos) JavaServer Page por desplegar el resultado. Usando esta solución, puede ser difícil de desarrollar ese servlet. Así como es responsable para un conjunto de casos de uso, se puede tener que llevar a cabo mucha lógica en ese servlet. En otro caso se puede tener tantos servlets como JavaServer Pages y encadenarlos. Esto significa que un servlet obtiene un requerimiento, ejecuta la acción correcta, y llama al JavaServer Page específico para ese servlet, para desplegar el resultado. Un requerimiento de ese JSP entonces obtiene otro servlet, y así sucesivamente. Será difícil mantener muchos servlets y JSP, puede confundirse al intentar entender el flujo de la aplicación.

CAPÍTULO 4. LOS SERVLETS

84

Una solución que tiene una granularidad entre esos extremos es dividiendo la aplicación en estados diferentes. Se intenta transferir un diagrama de transición de estados (por ejemplo, modelado con RationalRose) en páginas HTML, servlets y JavaServer Pages. Applicabilidad. Este modelo puede usarse en toda aplicación servlet /JSP. Es recomendable este modelo sobre todo en las aplicaciones Web complejas donde muchas páginas Web y transiciones de páginas tienen que ser desarrolladas. Componentes. Los componentes en esta estructura son: • Servlet: Un requerimiento dado recoge los datos requeridos para el despliegue de un estado dado o invoca la acción que causa una transición fuera del estado. Esta responsabilidad lo hace el controlador en un Modelo-Vista-Controlador (MVC) basado en la aplicación. • JavaServerPage: Es el indicador de la generación de código HTML para un resultado del requerimiento dado. • Wrapper de Tareas: Encapsula el acceso al proceso empresarial de negocios (datos back-end y función). Esta función realiza el modelo de wrapper de tareas en una aplicación MVC. • Páginas HTML: En caso de contenido estático y transiciones de estado, no es necesario tecnologías complejas. Un indicador de estado estático de página HTML. Colaboradores. Un flujo de aplicación Web puede capturarse en un diagrama de transición de estado (que es, a propósito, una documentación buena para el flujo de la aplicación). Un diagrama de transición de estado contiene nombres de estado conectados con los nombres de las ramas. La solución,es trazar cada componente del diagrama de transición de estado a un componente de la arquitectura de e-business para que pueda manejarse mediante WebSphere Aplication Server.

CAPÍTULO 4. LOS SERVLETS

85

Se separa en el diagrama los estados estáticos y los estados dinámicos. Las transiciones de estado estáticos son inherentes. Como ellos son estáticos en el controlador y en las transiciones, se puede codificar un estado como una página HTML que debe ser nombrado después del estado: < el Estado >.html. Cuando hereda estados dinámicos, es un tanto más dificultoso. Conforme a la arquitectura e-business, se divide el estado en modelo, vista y controlador. Controlador. El servlet actúa como el controlador de estado en este escenario. Esto significa que se captura un servlet por estado dinámico. Nombrando la convención, el servlet es llamado después del estado: < State>Servlet. Haciendo esto se consigue un método fácil de documentación. Pensando sobre cada interacción entre el navegador y el servidor de aplicaciones Web (por ejemplo, el servlet) como una sola unidad de trabajo, de sólo lectura o de actualización. Hay dos flujos básicos de modelos de control, ambos, llevado a cabo por el servlet. Uno se ocupa del despliegue para un estado dado, y el otro maneja las acciones que causan un cambio de estado. Despliegue de Patrones. Este modelo normalmente se manifiesta dentro de HTML como un link, resultando en un requerimiento Get. El flujo de control para este modelo es: • El servlet invoca el método apropiado de sólo lectura en el modelo de estado (ese es el wrapper de la tarea) y selecciona el JSP para ocuparse del resultado. • El servlet inicializa el objeto de datos asociado con el JSP, carga el resultado y coloca la vista del bean en un atributo HttpRequest. • El servlet remite la demanda al JSP escogido. • La Página de JavaServer genera el código del HTML. • El servlet envía el requerimiento al JSP seleccionado. • El JSP genera el código HTML. Vistas.

Las vistas se implementan como un JSP. Cosecuencias. Usando este modelo, es posible conseguir un acercamiento bueno para diseñar una aplicación Web, mediante la utilización de servlets, JSPs, wrapper de tareas y páginas HTML [2].

Capítulo 5

Introducción al DB2 Express-C 9

DB2 Express-C es un miembro de la familia IBM DB2 de poderosas aplicaciones de servidores de datos para manejar tanto datos relacionales como XML. DB2 Express-C es una edición de DB2 libre, sin límites y fácil de usar. La C en DB2 Express-C significa Comunidad. Una comunidad de usuarios DB2 Express-C que se juntan para ayudarse unos a otros, tanto en línea como fuera de ella. La comunidad DB2 Express-C consiste en una variedad de personas y compañías que diseñan, desarrollan, implementan o utilizan soluciones de base de datos, como: 87

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

88

Desarrolladores de aplicaciones que requieren un software de base de datos de estándar abierto para construir aplicaciones standalone, clienteservidor, Web y empresariales. ISVs, vendedores de hardware, vendedores de infraestructura de pila y proveedores de otros tipos de solución que quieran incluir o empotrar un completo servidor de datos como parte de sus soluciones. Consultores, administradores de base de datos y arquitectos IT que necesiten un servidor de datos robusto para entrenamiento, desarrollo de habilidades, evaluación y prototyping. Startups, pequeñas y medianas compañías que necesitan un servidor de datos confiable para sus aplicaciones y operaciones. Estudiantes, profesores y otros usuarios académicos que quieran un servidor de datos altamente versátil para enseñanza, courseware, proyectos e investigaciones [3]. DB2 Express-C comparte el mismo núcleo de funcionalidad y código base como las ediciones pagadas de DB2 para Linux, UNIX y Windows. DB2 Express-C puede correr en sistemas de 32-bits y 64-bits con sistemas operativos Windows o Linux. Puede correr en un sistema que tenga cualquier cantidad de núcleos y de memoria. No tiene ningún requerimiento especial de almacenamiento o de configuración del sistema que sean especiales. DB2 Express-C también incluye pureXML sin costo. pureXML es la tecnología única de DB2 para almacenar y procesar documentos XML nativamente. [4]

5.0.13.

Servidores DB2

Todas las ediciones de servidores DB2 contienen el mismo núcleo de componentes; están empaquetados de tal manera que los usuarios puedan escoger las funciones que necesitan al precio correcto. Figura 5.1 de la página 89 ilustra las diferentes ediciones de productos DB2. Como se muestra en la figura 5.1, DB2 Express-C es igual que DB2 Express solo que sin algunos componentes. DB2 Express-C es libre a la comunidad. La figura 5.1 también explica porqué es tan fácil actualizar desde DB2 Express-C. Si se desea actualizar a cualquier otro servidor DB2 en el futuro,

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

89

Figura 5.1: Servidores DB2. todos los servidores DB2 tienen el mismo núcleo de componentes. Esto también significa que una aplicación desarrollada para una edición trabajará, sin ninguna modificación, en otra edición. Y cualquier habilidad aprendida en una edición aplicará a las otras ediciones.

5.0.14.

Clientes DB2 y Controladores

Un cliente DB2 incluye las funcionalidades necesarias para conectarse a un servidor DB2, sin embargo, un cliente no siempre tiene que ser instalado. Por ejemplo, una aplicación JDBC Type 4 puede conectarse directamente a un servidor DB2, previsto del correcto controlador ya cargado. Los clientes DB2 vienen en diferentes formas: Cliente Servidor de Datos IBM (IBM Data Server Client): el más completo, incluye herramientas GUI, controladores. Cliente de Tiempo de Ejecución de Servidor de Datos (IBM Data Server Runtime Client): funcionalidad básica para conectarse e incluye controladores. Módulos fusionados de Cliente de Tiempo de Ejecución DB2 para Windows (DB2 Runtime Client Merge Modules for Windows): principalmente usado para incluir un cliente de Tiempo de Ejecución DB2 como

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

90

parte de la instalación de una aplicación Windows [5]. Aunque todos los clientes DB2 incluyen sus controladores requeridos, a partir de DB2 9 se proveen controladores individuales también. Todos los clientes DB2 y controladores son gratis y disponibles para descargar desde el sitio Web de DB2 Express-C. Los clientes y controladores pueden ser usados para conectarse a un servidor DB2 en Linux, UNIX o Windows. Para conectarse a servidores DB2 para z/OS R o DB2 para i5/OS R es necesario ir a través de un servidor DB2 Connect.

5.0.15.

Características y Productos Relacionados

Las características incluidas en la versión gratuita de DB2 Express-C son: La funcionalidad base de DB2. Control Center, Data Studio y otras herramientas de manejo pureXML. Utilización de recursos hasta 2GB y 2 núcleos. Disponible en Linux, Windows, y Solaris (x86). Las capacidades disponibles con la licencia de 12 meses de DB2 Express-C son: Fix packs. Alta disponibilidad y Recuperación Critica (HADR). Data Replication (Homogenous SQL). Utilización de recursos hasta 4GB y 4 núcleos (en 2 tomas).

5.0.16.

Características incluídas en otras ediciones de DB2:

Características pagadas en la edición DB2 Express: pureXML.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

91

Alta disponibilidad. Federación Homogénea. Características incluidas sin costo en la edición DB2 Workgroup: Alta disponibilidad. Disponible en AIX R , Solaris, y HP-UX además de Linux y Windows. Características pagadas en la edición DB2 Workgroup: pureXML. Optimización de Performance (MQT, MDC, Query Parallelism). Federación Homogénea. Características incluídas sin costo en la edición DB2 Enterprise: Particionamiento de Tablas (Range). Materialized Query Tables (MQT ). Multi-dimensional Clustering (MDC ). Alta disponibilidad y Recuperación Critica (HADR). Conexión Concentrada. Características pagadas en la edición DB2 Enterprise: pureXML. Optimización de almacenamiento (incluido compresión). Control de acceso avanzado (seguridad avanzada). Optimización del Performance (Performance Experto, Query Patroller ).

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

92

Administración de datos Geodetic. Federación Homogénea DB2. Productos pagados relacionados a DB2 : DB2 Connect. DB2 Warehouse Editions. WebSphere R Federation Server. WebSphere Replication Server.

5.0.17.

Características Incluidas con la Licencia de Suscripción de DB2 Express-C

Fix Packs Un fix pack de DB2 es un paquete de código corregido aplicado en un producto DB2 instalado, para corregir publicaciones diferentes después de que el producto fue liberado. Con una licencia de suscripción, la corrección de paquetes es gratis para descargar e instalar [6]. Alta disponibilidad de Recuperación Critica (HADR) Alta disponibilidad de Recuperación Crítica (HADR) es una característica de fiabilidad de base de datos que proporciona una alta disponibilidad y la solución de recuperación de datos ante desastres de sitio completos así como parciales. Un ambiente HADR generalmente consiste en dos servidores de datos, el primario y el secundario (que puede estar en posiciones geográficamente distantes). El servidor primario es donde la fuente de base de datos es almacenada y accesada por aplicaciones de clientes. Como las transacciones son procesadas sobre la base de datos primaria, los registros de la base de datos automáticamente son transportados al servidor secundario a través de la red. El servidor secundario tiene una copia clonada de la base de datos primaria, por lo general creada por el back-up de la base de datos primaria y restaurándolo sobre la base de datos secundaria. Cuando

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

93

los registros de la base de datos primaria son recibidos ellos son reproducidos de nuevo y aplicados a la base de datos secundaria. Por la repetición continua de los registros, la base de datos secundaria mantiene una réplica en sincronización de la base de datos primaria que puede asumir si la base de datos primaria falla. Una solución completa de DB2-supported HADR Capacidad rápida de solución ante fallas, con transparencia completa para clientes y aplicación de cliente. Atomicidad completa en las transacciones para prevenir perdida de datos. Habilidad de actualizar sistemas o aplicaciones sin interrupción de servicios visibles. Sistema remoto de fallas, proporcionando recuperación completa de desastre local que puede dañar el centro de datos. Administración fácil con herramientas graficas de DB2. Todos esto con un impacto insignificante sobre funcionamiento total del sistema. Réplica de Datos Esta característica permite la réplica de datos entre un servidor fuente donde los cambios de datos con capturados, y un servidor objetivo donde el cambio de datos son aplicados. La figura 5.2 de la página 94 proporciona una descripción de cómo trabaja la réplica. En la figura hay dos servidores, un servidor fuente y un servidor objetivo. En el servidor fuente, el programa Capture captura el cambio hecho en la base de datos. En el servidor objetivo, un programa Apply aplica los cambios de la base de datos replica. La réplica es útil para una variedad de propósitos que requieren replica de datos, incluyendo alivio de capacidad, sosteniendo el data warehouse y el mercado de datos, revisando el historial de cambios. Usando las características de la réplica SQL puedes replicar datos entre DB2 Express-C y otros servidores DB2, incluyendo aquellos en otros sistemas Linux, UNIX, z/OS, y i5/OS.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

94

Figura 5.2: Réplica de SQL.

5.0.18.

Características No Disponibles con DB2 Express-C

Esta sección describe alguna de las características disponibles en otras ediciones de DB2 pero no en DB2 Express-C. Particionamiento de la Base de Datos La característica de particionamiento de la base de datos (DPF ) es solo disponible con DB2 Enterprise Edition con la licencia de pago adicional. Esto permite a la base de datos ser extendido a través de múltiples particiones los cuales pueden estar alojados en varias computadoras. DPF está basado en una arquitectura shared-nothing. Cada computadora, como es añadido al grupo de partición, trae el poder adicional de procesamiento de datos con sus propias CPUs y memoria. DPF es en particular útil en ambientes de servidor de datos grandes como data warehouses donde las sentencias de los sistemas de apoyo de decisión (DSS ) son controlados.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

95

Concentrador de Conexión El concentrador de conexiones es una característica que permite el soporte de un largo número de usuarios conectados simultáneamente. Previamente, toda conexión a la base de datos requiere un agente de base de datos. El concentrador de conexiones introduce el concepto de un agente lógico, permitiendo un agente para mantener muchas conexiones. Geodetic Extender DB2 Geodetic Extender esta disponible con pago adicional para DB2 Enterprise Edition. Este extender hace desarrollos para aplicaciones de inteligencia de negocios y egovernment que requieren un análisis de localización geográfica mucho más sencillo. DB2 Geodetic Extender puede construir un globo mundial virtual a cualquier escala. La mayoría de información de localización es tomada usando sistemas worldwide, por ejemplo el sistema de satélites de posicionamiento global (GPS ), y puede ser representado en coordenadas de latitud/longitud (geocódigo). Los datos de negocios, como direcciones, pueden ser convertidos a geocódigo con DB2 Geodetic Extender y aplicaciones a nivel empresarial trabajan mejor cuando mantienen los datos en esta forma sin proyección, saliendo las proyecciones del mapa (tierra a mapa plano) donde ellos pertenecen, en la capa de presentación, para mostrar e imprimir mapas. Workload Management (WLM) Maneja cargas de trabajo en una base de datos en base a prioridades de un usuario y de aplicaciones combinadas con la disponibilidad de recursos y límites. Permite regular la carga de trabajo de tu base de datos y consultas, de tal manera que consultas importantes y de alta prioridad pueden corer inmediatamente, y , and previene consultas espontáneas que no tienen buen rendimiento de monopolizar los recursos del sistema de manera que tu sistema puede correr eficientemente. WLM is Nuevo en DB2 9.5 y prove mas poder que las características de las herramientas Query Patroller y del DB2 Governor que eran disponibles en versiones anteriores de DB2.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

96

Figura 5.3: DB2 Connect.

5.0.19.

Productos Pagados Relacionados con DB2

DB2 Connect DB2 Connect es un software pagado que permite al cliente DB2 para Linux, UNIX o Windows conectarse a un servidor DB2 para z/OS o para i5/OS, como se muestra en la figura 5.3 de la página 96. DB2 Connect no es requerido cuando la conexión ocurre en la dirección opuesta: cuando se conecta desde DB2 para z/OS o i5/OS hacia DB2 para Linux, UNIX o Windows. DB2 Connect viene en dos ediciones principales dependiendo de las necesidades de conexión: DB2 Connect Personal Edition y DB2 Connect Enterprise Edition. WebSphere Federation Server Antiguamente conocido como WebSphere Information Integrator (para soporte de federación), WebSphere Federation Server permite una federación de

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

97

base de datos; significando que puedes correr consultas de base de datos que puedan trabajar con objetos de diferentes sistemas de base de datos relacional. Por ejemplo, con WebSphere Federation Server, se puede correr la siguiente consulta:
SELECT * FROM Oracle.Table1 A DB2.Table2 B SQLServer.Table3 C WHERE A.col1 < 100 and B.col5 = 1000 and C.col2 = “Test’

La figura 5.4 de la página 98 provee una ilustración donde WebSphere Federation Server es usado. WebSphere Replication Server Antiguamente conocido como WebSphere Information Integrator (para soporte de replicación), WebSphere Replication Server permite replicación SQL en registros de base de datos cuando servidores de datos que no son de IBM están involucrados. Esto también incluye una característica conocida como Q-Replication para replicar información usando cola de mensajes.

5.0.20.

Guía de Instalación de DB2 Express C

Este apartado explicará paso a paso una instalación básica de DB2 ExpressC en Windows. La misma installation wizard está disponible en Linux ; por lo tanto los pasos son similares en ambas plataformas.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

98

Figura 5.4: WebSphere Federation Server.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

99

Procedimiento 1. Obtener la imágen de DB2 Express-C. Descargar la imágen apropiada de DB2 Express-C, u ordenar el Discovery Kit DVD que incluye la imágen del DB2 Express -C de la página Web www.ibm.com/db2/express. 2. Descomprimir los archivos en el directorio que se desee. 3. Localizar los archivos. Dirígirse hacia el directorio (o unidad) en donde se encuentran los archivos de instalación que se han descomprimido. 4. Correr el Launchpad. Ejecutar el DB2 Launchpad haciendo doble clic en el archivo setup.exe. En Linux, ejecutar el commando db2setup como root. En el Launchpad, clic en la opción Install Product en el panel izquierdo de la ventana. 5. Correr el DB2 setup wizard. El DB2 setup wizard revisa si cumple todos los requerimientos del sistema y ve si existe otra instalación de DB2. Hacer clic en el botón Next para seguir con la instalación. 6. Revisar los términos de licencia. Leer y aceptar los términos de licencia (seleccionar el radio button I Accept...) y clic al botón Next para continuar. 7. Elegir el tipo de instalación. En este caso, seleccionar la opción Typical (opción por defecto). La opción Compact realiza una instalación básica, mientras la opción Custom permite personalizar la configuración específica que se quiere instalar. Clic en el botón Next para continuar. 8. Seleccionar la carpeta para la instalación. Esta pantalla permite elegir la unidad y el directorio donde el código de DB2 es instalado en el sistema. Asegurarse de que exista espacio suficiente para la instalación. Usar la unidad y el directorio por defecto para este ejemplo (mostrado a continuación): Unidad: C: Directorio: C:\Archivos de Programa\ IBM\ SQLLIB. Clic en el botón Next para continuar. 9. Configurar la información del usuario. Una vez que DB2 Express-C está instalado, asegurarse que los procesos de DB2 están corriendo como Servicios del Sistema. Estos servicios requieren una cuenta del sistema operativo para poder correrlo. En el ambiente de Windows, usar la cuenta por defecto db2admin es recomendada. Si esta cuenta aun no existe, DB2 la creará en el Sistema Operativo. También se puede especificar

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

100

una cuenta existente, pero esa cuenta debe tener los permisos de administrador local. Se recomienda usar las opciones sugeridas. Asegurarse de especificar el password para la cuenta. En Linux se usa el UserID por defecto db2inst1 (dueño de la instancia), db2fenc1 (usuario para rutinas limitadas) y dasusr1 (usuario del DB2 Administrator Server, DAS ). Clic en el botón Next para continuar. 10. Configurar la instancia DB2. Pensar en el concepto de instancia DB2 como un contenedor para bases de datos. Una instancia debe existir antes de que una base de datos pueda ser creada dentro de ella. En una instalación en Windows, la instancia llamada DB2 se creará automáticamente. En Linux, el nombre por defecto de la instancia es db2inst1. Por defecto, la instancia DB2 esta configurada para escuchar conexiones TCP/IP en el puerto 50000. El protocolo por defecto y el puerto pueden ser cambiados dándole clic en Protocols y el botón Startup, respectivamente. Se recomienda usar las opciones por defecto para este ejemplo. Clic en el botón Next para continuar. 11. Comenzar con la instalación. Revisar las opciones de instalación seleccionadas previamente. Hacer clic en el botón Install para comenzar a copiar los archivos a la carpeta destino de instalación. DB2 también realizará algunos procesos de configuración iniciales. 12. Primeros pasos. Luego que la instalación ha terminado, otra herramienta llamada First Steps arranca automaticamente. First Steps también puede ser arrancada con el comando db2fs. 13. La base de datos SAMPLE es una base datos que se puede usar para probar DB2. Esta es creada automáticamente luego de la instalación de DB2. Verificar que la base de datos exista abriendo la herramienta DB2 Control Center. Para abrir esta herramienta, del botón Inicio de Windows elegir: Inicio → Programas → IBM DB2 →DB2COPY1 (Default) → General Administration Tools → Control Center. Ademas se puede iniciar el Control Center con el comando db2cc. 14. Si la base de datos SAMPLE se muestra en el Control Center, se puede saltar al paso 16. Si no se muestra, seleccionar el item Refresh del menu Control Center View para asegurar que se puede ver toda la información refrescada. Si la base de datos SAMPLE sigue sin aparecer, es porque no ha sido creada. Habrá que crearla manualmente del First Steps. Elegir donde dice Database Creation, y luego guiarse con el Wizard para crear

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

101

Figura 5.5: Ventana de Progreso en DB2. la base de datos SAMPLE. Asegurarse que los objetos XML y SQL y las opciones de datos son seleccionados, y luego clic en OK. Esta última opción creará una base de datos UNICODE el cual fue requerido en la version 9 para soportar XML puro (pureXML), pero no es necesario en DB2 9.5. 15. La siguiente ventana que se visualiza en la figura 5.5 de la página 101, aparece cuando la base de datos esta siendo creada. (Este procedimiento puede tomar algunos minutos). Cuando la base de datos es creada, clic en el botón OK y cerrar la herramienta First Steps.

1. Regresar al Control Center y verificar que la base de datos SAMPLE aparezca en el panel Object Tree. Se debe refrescar la vista del Control Center para ver los nuevos cambios efectuados. Para hacer esto, seleccionar el item Refresh del menu Control Center View. 2. Reiniciar la computadora. A pesar que este paso no esta mencionado en la documentación oficial de instalación DB2, se recomienda reiniciar el sistema (si es posible, por lo menos en Windows) para asegurarse que todos los procesos comiencen satisfactoriamente y limpien cualquier recurso de memoria que no han sido eliminados correctamente. Esto es OPCIONAL.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

102

Figura 5.6: Herramientas DB2.

5.0.21.

Herramientas de DB2

En este apartado, se describirán algunas de las herramientas que se pueden usar con DB2. La elipse roja en la figura 5.6 de la página 102 muestra el área en la que se centra este apartado. La figura 5.7 lista todas las herramientas disponibles en el menú de inicio de DB2. La mayoría de esas herramientas son las mismas en Linux y Windows. La tabla 5.1 de la página 103 provee una lista de comandos que pueden ser usados para iniciar algunas de las herramientas más populares tanto en Linux o Windows.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

103

Figura 5.7: Herramientas DB2: Menú Inicio.

Herramienta Editor de Comandos Command Line processor Ventana de Comandos Control Center Task Center Health Center Configuration Assistant First Steps

Comando db2ce db2 db2cmd db2cc db2tc db2hc db2ca db2fs

Cuadro 5.1: Comandos Para Iniciar Algunas Herramientas DB2.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

104

Figura 5.8: Centro de Control de DB2. Centro de Control (Control Center) La herramienta primaria para la administración de DB2 es el Centro de Control, ilustrado en la figura 5.8 de la página 104. El Centro de Control es una herramienta de administración centralizada que permite: Ver el sistema, instancias, bases de datos y objetos de la base de datos; Crear, modificar y manejar objetos de las bases de datos; Lanzar otras herramientas gráficas de DB2. El panel del lado izquierdo provee una visión jerárquica de los objetos de la base de datos en el sistema, teniendo una carpeta para Tablas, Vistas, etc. Al hacer doble clic sobre una carpeta, del lado derecho se listarán todos los objetos relacionados, como por ejemplo, todas las tablas asociadas con la base de datos SAMPLE. Si se selecciona una tabla en la parte alta del panel, en la

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

105

parte baja del lado derecho del panel se proveerá información más específica acerca de esa tabla. Al hacer clic derecho sobre los diferentes objetos/carpetas en el árbol de objetos es posible ver el menú con las opciones aplicables a los objetos/carpetas [6]. La primera vez que se lanza el Centro de Control, preguntará qué vista se prefiere usar. La elección de la vista determina qué tipo de opciones y objetos de la base de datos son expuestos: La vista básica provee la funcionalidad elemental. La vista avanzada muestra más opciones y mejoras. La vista personalizada permite ajustar las mejoras específicas, opciones y objetos que se mostrarán. Cómo Lanzar el Centro de Control Hay varias formas de lanzar el Centro de Control : Navegando a través del menú de inicio de Windows. Ejecutando db2cc en la línea de comandos. Dando clic en el icono de el Centro de Control en la barra de herramientas de cualquier otra herramienta gráfica de DB2. Desde el icono DB2 en Windows como se muestra en la figura 5.9 de la página 106 (Da clic sobre el icono verde DB2 y seleccionar la opción Central de Control de DB2 ).

El Editor de Comandos DB2 Usando el Editor de Comandos DB2 (editor de comandos), se pueden ejecutar comandos DB2, sentencias SQL y XQuery, analizar el plan de ejecución de una sentencia, y ver o actualizar resultados de consultas. La figura 5.10 de la página 106 muestra el Editor de Comandos.

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

106

Figura 5.9: Icono DB2 en Windows.

Figura 5.10: Editor de Comandos.

Figura 5.11: Botón Show SQL. En el área de entrada, se pueden ingresar varias sentencias, tan largas hasta que se presente el caracter de finalización. Si se presiona el botón ejecutar, las sentencias serán ejecutadas una después de otra. Si se selecciona explícitamente una sentencia, sólo esa sentencia será ejecutada. Debe existir una conexión a la base de datos para devolver sentencias SQL, sin embargo, una de esas sentencias puede ser una sentencia de conexión. SQL Assist Wizard Si no se está familiarizado con el lenguaje SQL se podría usar un asistente para generar código SQL, el SQL Assist Wizard está disponible en el Editor de Comandos para ayudarte. Como se muestra en la figura 5.11, invócalo desde el Editor de Comandos dando clic sobre le último icono con el símbolo SQL. Su uso es bastante claro. Primero indica el tipo de sentencia SQL para la cual se necesita asistencia (SELECT, INSERT, UPDATE, DELETE). Dependiendo de que sentencia se haya elegido, diferentes opciones aparecerán. En la parte baja de la ventana mostrará cómo la sentencia SQL es construida a partir de diferentes elecciones en el asistente [4]. El Botón Show SQL La mayoría de las herramientas gráficas y los asistentes en DB2 permiten revisar el comando actual o la sentencia SQL que es creada como resultado de usar la herramienta para realizar tal acción. Para ver esto, da clic en el botón Show SQL en la herramienta en la que se está trabajando, como lo muestra la figura 5.11 y figura 5.12 en las páginas 107 y 108 respectivamente. La posibilidad de revisar las sentencias SQL y comandos es muy útil para aprender sintaxis SQL, y para guardar comandos o sentencias para su posterior uso. También se puede construir scripts re usando esos comandos y sentencias generados [7].

CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9

108

Figura 5.12: Salida de un Botón Show SQL.

Capítulo 6

Eclipse

6.1.

¿Que es Eclipse?

Eclipse es principalmente una plataforma de programación, usada para crear entornos integrados de desarrollo (del Inglés IDE). Eclipse fue desarrollado originalmente por IBM Canadá, desarrollado por OTI (Object Technology International) como reemplazo ó el sucesor de su 109

CAPÍTULO 6. ECLIPSE

110

familia de herramientas para VisualAge. Eclipse es ahora desarrollado por la Fundación Eclipse, una organización independiente sin ánimo de lucro que fomenta una comunidad de código abierto y un conjunto de productos complementarios, capacidades y servicios. Eclipse es también una comunidad de usuarios, extendiendo constantemente las áreas de aplicación cubiertas. Un ejemplo es el recientemente creado Eclipse Modeling Project, cubriendo casi todas las áreas de Model Driven Engineering. La licencia de Eclipse fue liberada originalmente bajo la Common Public License, pero después fue re-licenciada bajo la Eclipse Public License. La Free Software Foundation ha dicho que ambas licencias son licencias de software libre, pero son incompatibles con Licencia Pública General de GNU (GNU GPL) [2].

6.2.

¿Como Utilizar Eclipse?

Eclipse es un entorno de desarrollo integrado de código abierto multiplataforma para desarrollar lo que el proyecto llama “Aplicaciones de Cliente Enriquecido”, opuesto a las aplicaciones “Cliente-liviano” basadas en navegadores. Esta plataforma, típicamente ha sido usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega como parte de Eclipse y que son usados también para desarrollar el mismo Eclipse. Sin embargo, también se puede usar para otros tipos de aplicaciones cliente, como BitTorrent Azureus [8].

CAPÍTULO 6. ECLIPSE

111

Frame principal de desarrollo de Eclipse.

El entorno de desarrollo integrado (IDE) de Eclipse emplea módulos (en inglés plug-in) para proporcionar toda su funcionalidad al frente de la plataforma de cliente rico, a diferencia de otros entornos monolíticos donde las funcionalidades están todas incluidas, las necesite el usuario o no. Este mecanismo de módulos es una plataforma ligera para componentes de software. Adicionalmente a permitirle a Eclipse extenderse usando otros lenguajes de programación como son C/C++ y Python, permite a Eclipse trabajar con lenguajes para procesado de texto como LaTeX, aplicaciones en red como Telnet y Sistema de gestión de base de datos. La arquitectura plugin permite escribir cualquier extensión deseada en el ambiente, como sería Gestión de la configuración. Se provee soporte para Java y CVS en el SDK de Eclipse. Y no tiene por qué ser usado únicamente para soportar otros lenguajes de programación. La definición que da el proyecto Eclipse acerca de su software es una especie de “herramienta universal” - un IDE abierto y extensible para todo y nada en particular.

CAPÍTULO 6. ECLIPSE

112

En cuanto a las aplicaciones clientes, eclipse provee al programador con frameworks muy ricos para el desarrollo de aplicaciones gráficas, definición y manipulación de modelos de software, aplicaciones web, etc. Por ejemplo, GEF (Graphic Editing Framework - Framework para la edición gráfica) es un plugin de Eclipse para el desarrollo de editores visuales que pueden ir desde procesadores de texto hasta editores de diagramas UML, interfaces gráficas para el usuario (GUI), etc. Dado que los editores realizados con GEF viven dentro de Eclipse, además de poder ser usados conjuntamente con otros plugins, hacen uso de su interfaz gráfica personalizable y profesional. El SDK de Eclipse incluye las herramientas de desarrollo de Java, ofreciendo un IDE con un compilador de Java interno y un modelo completo de los archivos fuente de Java. Esto permite técnicas avanzadas de refactorización y análisis de código. El IDE también hace uso de un espacio de trabajo, en este caso un grupo de metadata en un espacio para archivos plano, permitiendo modificaciones externas a los archivos en tanto se refresque el espacio de trabajo correspondiente.

La instalación del Eclipse es muy sencilla, se puede descargar gratuitamente de www.eclipse.org en forma de archivo ZIP y se descomprime en la carpeta donde se quiere instalar. Para ejecutar solo hay que arrancar el fichero Eclipse.exe . Una vez arrancado lo único que se pide es que se le dé la ruta

por defecto donde se quiere que Eclipse vaya guardando los proyectos que se vayan creando.

Eclipse puede utilizar varias perspectivas en su ventana principal dependiendo del tipo de desarrollo que se vaya a realizar. En el presente trabajo se utilizó la perspectiva “Java”. Una vez que se termina el proyecto, el mismo se puede probar mediante la ejecución del programa para ver si funciona, ya que el mismo posee un área donde se puede hacer correr el servidor de prueba y probar la aplicación realizada, de esta forma es un entorno versatil y sencillo para poder realizar los programas en java [2].

Capítulo 7

Introducción al Servidor Tomcat 5.0
7.1. Descripción

Tomcat (también llamado Jakarta Tomcat o Apache Tomcat) funciona como un contenedor de servlets desarrollado bajo el proyecto Jakarta en la Apache Software Foundation. Tomcat implementa las especificaciones de los servlets y de JavaServer Pages (JSP) de Sun Microsystems.

7.2.

Entorno

Tomcat es un servidor web con soporte de servlets y JSPs. Tomcat no es un servidor de aplicaciones, como JBoss o JOnAS. Incluye el compilador Jasper, que compila JSPs convirtiéndolas en servlets. El motor de servlets de Tomcat a menudo se presenta en combinación con el servidor Web Apache [9]. Tomcat puede funcionar como servidor web por sí mismo. En sus inicios existió la percepción de que el uso de Tomcat de forma autónoma era sólo recomendable para entornos de desarrollo y entornos con requisitos mínimos de velocidad y gestión de transacciones. Hoy en día ya no existe esa percepción y Tomcat es usado como servidor Web autónomo en entornos con alto nivel de tráfico y alta disponibilidad. 114

CAPÍTULO 7. TOMCAT

115

Dado que Tomcat fue escrito en Java, funciona en cualquier sistema operativo que disponga de la máquina virtual Java [2].

7.3.

Estado de su Desarrollo

Tomcat es mantenido y desarrollado por miembros de la Apache Software Foundation y voluntarios independientes. Los usuarios disponen de libre acceso a su código fuente y a su forma binaria en los términos establecidos en la Apache Software Licence. Las primeras distribuciones de Tomcat fueron las versiones 3.0.x. Las versiones más recientes son las 6.x, que implementan las especificaciones de Servlet 2.5 y de JSP 2.1. A partir de la versión 4.0, Jakarta Tomcat utiliza el contenedor de servlets Catalina [10].

7.4.

Estructura de Directorios

La jerarquía de directorios de instalación de Tomcat incluye: bin - arranque, cierre, y otros scripts y ejecutables. common - clases comunes que pueden utilizar Catalina y las aplicaciones web. conf - ficheros XML y los correspondientes DTD para la configuración de Tomcat. logs - logs de Catalina y de las aplicaciones. server - clases utilizadas solamente por Catalina. shared - clases compartidas por todas las aplicaciones web. webapps - directorio que contiene las aplicaciones web. work - almacenamiento temporal de ficheros y directorios.

7.5.

Características del Producto
Tomcat 3.x (distribución inicial):

• Implementado a partir de las especificaciones Servlet 2.2 y JSP 1.1. • Recarga de servlets. • Funciones básicas HTTP. Tomcat 4.x: • Implementado a partir de las especificaciones Servlet 2.3 y JSP 1.2. • Contenedor de servlets rediseñado como Catalina. • Motor JSP rediseñado con Jasper. • Conector Coyote. • Java Management Extensions (JMX), JSP Y administración basada en Struts. Tomcat 5.x: • Implementado a partir de las especificaciones Servlet 2.4 y JSP 2.0. • Recolección de basura reducida. • Capa envolvente nativa para Windows y Unix para la integración de las plataformas. • Análisis rápido JSP. Tomcat 6.x: • Implementado de Servlet 2.5 y JSP 2.1. • Soporte para Unified Expression Language 2.1. • Diseñado para funcionar en Java SE 5.0 y posteriores. • Soporte para Comet a través de la interfaz CometProcessor.

7.6.

Historia

Tomcat empezó siendo una implementación de la especificación de los servlets comenzada por James Duncan Davidson, que trabajaba como arquitecto de software en Sun Microsystems y que posteriormente ayudó a hacer al proyecto de código abierto y en su donación a la Apache Software Foundation. Duncan Davidson inicialmente esperaba que el proyecto se convirtiese en software de código abierto y dado que la mayoría de los proyectos de este tipo

CAPÍTULO 7. TOMCAT

117

tienen libros de O’Reilly asociados con un animal en la portada, quiso ponerle al proyecto nombre de animal. Eligió Tomcat (gato), pretendiendo representar la capacidad de cuidarse por sí mismo, de ser independiente [11].

Capítulo 8

Descripción de la Aplicación
8.1. Descripción General

El presente trabajo se basa en el desarrollo de un software que permite la gestión de una típica empresa agro-ganadera de una manera muy amigable al usuario final mediante una aplicación Web multiplataforma con acceso a base de datos. El Objetivo fue realizar una aplicación Web multiplataforma desarrollada en Java, en la cual el usuario final pueda contar con un medio para gestionar el establecimiento e interaccionar con otras disciplinas, a través de la red, brindando de esta manera mayor rapidez y eficiencia en la administración del mismo. La presente implementación de la aplicación llamada SAG (Sistema AgroGanadero) correrá en la plataforma Windows mediante el uso de software multiplataforma.

8.2.

Análisis

Como primera etapa en el desarrollo de la aplicación se realizó un análisis exhaustivo de la principal problemática de gestión que posee una empresa agro-ganadera. En las cuales se utilizaron distintas metodologías de análisis como Diagramas de contexto que se muestran en la figura 8.1 de la página 119 118

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

119

y casos de uso que son ejemplificados en la figura8.2 de la página119.

Figura 8.1: Diagrama de Contexto .

Figura 8.2: Caso de Uso.

8.3.

Desarrollo

De ésta forma el desarrollo de la aplicación se ajusta a las necesidades propias del establecimiento, ya que permite registrar y organizar la información obtenida para cualquiera de las actividades del mismo, ya sean agrícolas o

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

120

ganaderas, transformándose en una base de operaciones para el usuario final, ayudandolo a tomar las decisiones correctas en lo que se refiere a la administración del establecimiento, ya que podrán ver reflejados todos los movimientos, y así reducir los tiempos de respuesta para la toma de decisiones. En la figura 8.3 de la página 120 se puede observar la página principal de la Aplicación.

Figura 8.3: Página Principal de la Aplicación.

8.3.1.

Módulos

El sistema consiste básicamente en ocho módulos bien definidos: 1. Agricultura. 2. Ganadería. 3. Empleados. 4. Bancos.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

121

5. Clientes. 6. Proveedores. 7. Consultas. 8. Planillas. Agricultura Este módulo permite administrar los recursos productivos y las distintas actividades realizadas como: Cosechas. Siembras. Pulverizaciones. Rollos. Máquinas. Campos. Insumos . Ventas. Además permite gestionar las compras, ventas, rinde estimado y total. La figura 8.4 de la página 122 visualiza la página principal de Agricultura con sus diferentes secciones.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

122

Figura 8.4: Formulario de Agricultura. Cosecha Éste módulo permite manejar todas las operaciones de cosechas propias y a terceros, como también los traslados de las mismas. La figura 8.5 de la página 123 ilustra la pantalla con el formulario de carga de cosechas a terceros.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

123

Figura 8.5: Formulario de Carga Cosecha a Terceros. Siembra Éste módulo permite manejar todas las operaciones de siembra propia y a terceros. La figura 8.6 de la página 124 ilustra la pantalla con el formulario de carga de siembra propia.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

124

Figura 8.6: Formulario de Carga Siembra Propia. Rollos La sección de Rollos permite acentar los datos de las producciones de rollos propios y realizados a terceros. Dicha sección se visualiza en la figura 8.7 de la página 125.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

125

Figura 8.7: Formulario de Carga Rollos Propios. Máquinas Aquí es posible registrar el inventario de máquinas propias que posee la empresa. La página principal de este módulo se puede observar mediante la figura 8.8 de la página 126.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

126

Figura 8.8: Formulario de Modificar Máquinas. Pulverización En este apartado es posible registrar los trabajos de pulverizaciones realizadas por la empresa y, se puede visualizar su pantalla principal en la figura 8.9 de la página 127.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

127

Figura 8.9: Formulario de Carga Pulverizaciones a Terceros. Campos Aquí se registran los campos propios y alquilados que posee la empresa. Su pantalla principal se muestra en la figura 8.10 de la página 128.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

128

Figura 8.10: Formulario de Carga Campos Propios. Insumos Los insumos son registrados en esta sección y su pantalla principal es la que se muestra en la figura 8.11 de la página 129.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

129

Figura 8.11: Principal de Insumos. Ventas Este módulo permite registrar las ventas realizadas por la empresa. Se visualiza mediante la figura 8.12 de la página 130.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

130

Figura 8.12: Principal de Ventas.

8.3.2.

Ganadería

Este módulo permite llevar el control y la planificación de todos los lotes destinados a ganadería, observando su producción y su evolución a través del tiempo, además de manejar todos los movimientos de animales que se registren en el establecimiento, icluyendo: Ganado. Sanidad. Inseminación. Reproducción. Balanza. Campos.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

131

Isumos. Además permite analizar detalladamente todos lon ingresos y egresos de la actividad financiera de este sector. La figura 8.13 de la página 131 muestra la pantalla principal del módulo Ganadería, desde la cual se puede acceder a sus diferentes secciones.

Figura 8.13: Pantalla Principal de Ganadería. Ganado Esta sección permite manejar las operaciones relacionadas con el ganado, como ser, ingreso, egreso, muerte, parición, compra y venta. La figura 8.14 de la página 132 muestra la pantalla de inicio correspondiente.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

132

Figura 8.14: Pantalla Principal de la Sección Ganado. Sanidad Este apartado se encarga del registro de vacunación y baño del ganado. La figura 8.15 de la página 133 muestra los formularios de carga correspondientes.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

133

Figura 8.15: Formularios de Vacunación y Baño de Ganado. Inseminación Esta sección permite registrar todos los datos relacionados con las inseminaciones realizadas al ganado. La figura 8.16 de la página 134 visualiza el formulario.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

134

Figura 8.16: Formulario de Carga de Inseminaciones de Ganado. Reproducción y Balanza Estos módulos manejan el registro de los datos relacionados con la preñéz, tacto y peso del ganado. La figura 8.17 de la página 135 vizualiza los formularios correspondientes.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

135

Figura 8.17: Formularios de Reproducción y Balanza.

8.3.3.

Empleados

Este módulo maneja todas las operaciones de alta, baja y modificaciones de la relación laboral existente entre los empleados y la empresa. La figura 8.18 de la página 136 visualiza la pantalla principal de éste módulo.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

136

Figura 8.18: Página Principal de Empleados.

8.3.4.

Bancos

El módulo de Bancos permite registrar los movimientos financieros de la empresa, como ser, créditos bancarios, tarjetas de crédito, etc. En la figura 8.19 de la página 137 se puede observar la página inicial de éste módulo y la figura 8.20 de la página 138 visualiza los diferentes formularios que componen las seecciones disponibles.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

137

Figura 8.19: Página Principal del Módulo Bancos.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

138

Figura 8.20: Operaciones Financieras.

8.3.5.

Clientes

Este módulo permite realizar las operaciones de altas, bajas y modificaciones de la cartera de clientes de la empresa. El formulario de carga con los datos relacionados se puede visualizar en la figura 8.21 de la página 139.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

139

Figura 8.21: Principal de Clientes.

8.3.6.

Proveedores

Este módulo permite registrar todos los datos relacionados con los proveedores de la empresa, como se puede observar en la figura 8.22 de la página 140.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

140

Figura 8.22: Principal de Proveedores.

8.3.7.

Consultas

Este módulo ofrece al sistema la posibilidad de realizar consulta de toda la información disponible en la base de datos, mediante el armado de informes y una gran variedad de listados. En la fgura 8.23 de la página 141 se pueden apreciar algunos de los listados disponibles en el sistema.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

141

Figura 8.23: Ejemplos de Listados Arrojados por el Sistema.

8.3.8.

Planillas

Este módulo le ofrece al usuario la posibilidad de imprimir planillas vacías con los datos existentes en el sistema para su utilización en el campo. La figura de la página muestra algunas de las planillas disponibles para impresión.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

142

Figura 8.24: Ejemplo de Planillas Disponibles en el Sistema.

8.4.

Estructura de Datos

A continuación se mostrará todo lo relacionado con la estructura de la base de datos utilizada por la aplicación, la base de datos corre sobre el motor de base de datos multiplataforma DB2 Express-C. En el siguiente gráfico, se puede observar la base de datos utilizada por la aplicación.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

143

Figura 8.25: Estructura de la Base de Datos. La base de datos está compuesta por 28 tablas que se detallan a continuación:
AREA:

• NRO_AREA: INTEGER NOT NULL. • DES_AREA: VARCHAR(50) NOT NULL.
BANCO:

• COD_BANCO: INTEGER NOT NULL. • NOMBRE_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • DIRECCION_BANCO: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

144

• TELEFONO_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• TIPO_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • OBSERVACIONES_BANCO: VARCHAR(500) NOT NULL WITH DEFAULT
‘No tiene’.

• LOCALIDAD_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• PROVINCIA_BANCO: VARCHAR(50).
BANIO:

• COD_BANIO: INTEGER NOT NULL. • FECHA_BANIO: DATE NOT NULL. • EMPRESA: VARCHAR(30). • PRODUCTO: VARCHAR(30). • ENFERMEDAD: VARCHAR(30). • CANT_CABEZAS: BIGINT. • COSTO_CABEZA: BIGINT. • OTRO: BIGINT. • COSTO_TOTAL: BIGINT.
CAMPO:

• COD_CAMP: INTEGER NOT NULL. • NOMBRE_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • UBICACION_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.

• SUPERFICIE_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.

• FUNCION_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • PORCENTAJE_KG_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.

• PRECIO_HA_CAMP: DOUBLE NOT NULL. • TIPO_CAMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘Propio’. • EMPRESA_CAMP: VARCHAR(50).

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

145

• CANT_LOTES_CAMP: INTEGER. • KG_FIJADO_CAMP: DOUBLE.
CLIENTE:

• COD_CLIENT: INTEGER NOT NULL. • NOMBRE: VARCHAR(50) NOT NULL WITH DEFAULT ‘Sin Nombre’. • CUIT: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • TELEFONO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • EMAIL: VARCHAR(50) NOT NULL WITH DEFAULT ’No tiene’. • DOMICILIO: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • LOCALIDAD: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • NOMBREC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • APELLIDOC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • TELEFONOC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • EMAILC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • PROVINCIA: VARCHAR(30).
COSECHA:

• COD_COSECHA: INTEGER NOT NULL. • FECHA_COSECHA: DATE. • EMPRESA_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • MAQUINA_COSECHA: INTEGER. • OPERADOR_MAQ_COSECHA: INTEGER. • CAMPO_COSECHA: INTEGER. • LOTE_CAMPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • SUPERFICIE_COSECHA: VARCHAR(50) WITH DEFAULT ‘0’. • KG_HA_COSECHA: DOUBLE WITH DEFAULT 0. • KG_EQUIPO_COSECHA: DOUBLE WITH DEFAULT 0. • PROPIETARIO_EQUIPO_COSECHA: VARCHAR(100) WITH DEFAULT
‘No tiene’.

• PATENTE_EQUIPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • CANT_HA_COSECHA: DOUBLE WITH DEFAULT 0.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

146

• IMPORTE_HA_COSECHA: DOUBLE WITH DEFAULT 0. • IMPORTE_TOTAL_COSECHA: DOUBLE WITH DEFAULT 0. • CULTIVO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • TIPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘Propia’. • PORCENTAJE_PACTADO_COSECHA: DOUBLE WITH DEFAULT 0. • TN_COSECHA: DOUBLE WITH DEFAULT 0.0. • CLIENTE_COSECHA: INTEGER. • FORMA_PAGO_COSECHA: VARCHAR(20). • DESTINO_COSECHA: VARCHAR(50). • OPERADOR2_MAQ_COSECHA: INTEGER NOT NULL WITH DEFAULT
0.

• CARTA_APORTE_COSECHA: BIGINT WITH DEFAULT 0. • LOTE_NOM_COSECHA: VARCHAR(50) NOT NULL WITH DEFAULT ‘’.
CREDITO:

• COD_CRED: INTEGER NOT NULL. • FECHAE_CRED: DATE. • NRO_CRED: VARCHAR(20). • DESTINO_CRED: VARCHAR(30). • DURACION_CRED: INTEGER. • EMPRESA_CRED: VARCHAR(30). • BANCO_CRED: INTEGER. • TASA_INTERES_CRED: INTEGER. • TIPO_INTERES: VARCHAR(20). • TIPO_INTERES1: VARCHAR(20). • MONEDA_CRED: VARCHAR(30). • TIPO_PAGO_CRED: VARCHAR(30). • FECHAV_CRED: DATE. • OBSERVACIONES_CRED: VARCHAR(50). • TOTAL_CUOTAS_CRED: INTEGER. • IMPORTE_CRED: DOUBLE.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

147

FUMIGACION:

• COD_FUM: INTEGER NOT NULL. • FECHA_FUM: DATE. • EMPRESA_FUM: VARCHAR(50). • CAMPO_FUM: INTEGER. • LOTE_FUM: VARCHAR(50) WITH DEFAULT ‘’. • LOTE_NOM_FUM: VARCHAR(50) WITH DEFAULT ‘’. • MAQUINA_FUM: INTEGER. • OPERADOR_FUM: INTEGER WITH DEFAULT 0. • OPERADOR2_FUM: INTEGER WITH DEFAULT 0. • CULTIVO_FUM: VARCHAR(40). • CLIENTE_FUM: INTEGER. • PRODUCTO1_FUM: VARCHAR(50) WITH DEFAULT ‘’. • PRODUCTO2_FUM: VARCHAR(50) WITH DEFAULT ‘’. • PRODUCTO3_FUM: VARCHAR(50) WITH DEFAULT ‘’. • PRODUCTO4_FUM: VARCHAR(50) WITH DEFAULT ‘’. • DOSIS1_FUM: DOUBLE WITH DEFAULT 0.0. • DOSIS2_FUM: DOUBLE WITH DEFAULT 0.0. • DOSIS3_FUM: DOUBLE WITH DEFAULT 0.0. • DOSIS4_FUM: DOUBLE WITH DEFAULT 0.0. • MEDIDA1_FUM: VARCHAR(20) WITH DEFAULT ‘’. • MEDIDA2_FUM: VARCHAR(20) WITH DEFAULT ‘’. • MEDIDA3_FUM: VARCHAR(20) WITH DEFAULT ‘’. • MEDIDA4_FUM: VARCHAR(50) WITH DEFAULT ‘’. • CANTIDAD1_FUM: DOUBLE WITH DEFAULT 0.0. • CANTIDAD2_FUM: DOUBLE WITH DEFAULT 0.0. • CANTIDAD3_FUM: DOUBLE WITH DEFAULT 0.0. • CANTIDAD4_FUM: DOUBLE WITH DEFAULT 0.0. • HA_FUM: INTEGER. • COSTO_HA_FUM: DOUBLE WITH DEFAULT 0.0. • COSTO_TOTAL_FUM: DOUBLE WITH DEFAULT 0.0.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

148

• TIPO_FUM: VARCHAR(50).
GANADO:

• COD_GANADO: INTEGER NOT NULL. • EMPRESA_GANADO: VARCHAR(50). • NRO_DTA_GANADO: INTEGER. • NRO_RENSPA_GANADO: INTEGER. • CANT_CON_CVNA_GANADO: INTEGER. • CAN_SIN_CVNA_GANADO: INTEGER. • CANT_TOTAL_GANADO: INTEGER. • NRO_CVNA_DESDE_GANADO: INTEGER. • NRO_CVNA_HASTA_GANADO: INTEGER. • OBSERVACIONES_GANADO: VARCHAR(200). • NRO_CVNA_GANADO: INTEGER. • FECHA_GANADO: DATE. • CATEGORIA_GANADO: VARCHAR(50). • RAZA_GANADO: VARCHAR(50). • NRO_COMPROBANTE_GANADO: VARCHAR(50). • PESO_TOTAL_GANADO: DOUBLE. • PESO_PROMEDIO_GANADO: DOUBLE. • PRECIO_KG_GANADO: DOUBLE. • IMPORTE_CABEZA_GANADO: DOUBLE. • IMPORTE_TOTAL_GANADO: DOUBLE. • TIPO_MOVIMIENTO_GANADO: VARCHAR(50).
INSEMINA:

• COD_INSEMINA: INTEGER NOT NULL. • FECHA: DATE NOT NULL. • EMPRESA: VARCHAR(30). • RAZA: VARCHAR(20). • RODEO: VARCHAR(20).

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

149

• CATEGORIA: VARCHAR(20). • NRO_CARAVANA: BIGINT. • PRODUCTO: VARCHAR(30). • TORO: VARCHAR(20). • OBSERVACIONES: VARCHAR(200) NOT NULL WITH DEFAULT ‘’.
INSUMOS:

• COD_INS: INTEGER NOT NULL. • NOMBRE_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • MEDIDA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • CANTIDAD_INS: INTEGER NOT NULL WITH DEFAULT 0. • TIPO_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • PRECIO_INS: DOUBLE NOT NULL WITH DEFAULT 0. • OBSERVACIONES_INS: VARCHAR(200) NOT NULL WITH DEFAULT ‘No
tiene’.

• FACT_INS: INTEGER NOT NULL WITH DEFAULT 0. • NRO_FACT_INS: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • TIPO_ALIMENTO_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.

• TIPO_VETERINARIO_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.

• TIPO_COMBUSTIBLE_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.

• TIPO_AGROQUIMICO_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.

• TIPO_SEMILLA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.

• TIPO_FERTILIZANTE_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’ .

• MARCA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • MAQUINA_INS: INTEGER NOT NULL WITH DEFAULT 0. • PROVEEDOR_INS: INTEGER NOT NULL WITH DEFAULT 0. • FECHA_INS: DATE.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

150

• LUGAR_COMPRA_INS: VARCHAR(50) WITH DEFAULT ‘No tiene’. • TIPO_PAGO_INS: VARCHAR(20) NOT NULL WITH DEFAULT ”. • GASTO_TOTAL_INSUMO: DOUBLE NOT NULL WITH DEFAULT 0.
LOTES:

• COD_LOTE: INTEGER NOT NULL. • CAMPO_LOTE: INTEGER NOT NULL. • NOMBRE_LOTE: VARCHAR(20) NOT NULL.
MAQUINA:

• COD_MAQ: INTEGER NOT NULL. • MARCA_MAQ: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’. • MODELO_MAQ: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • PATENTE_MAQ: VARCHAR(50) NOT NULL. • ANIO_MAQ: VARCHAR(10) NOT NULL WITH DEFAULT ‘No tiene’. • PROPIETARIO_MAQ: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• DESC_MAQ: VARCHAR(500) NOT NULL WITH DEFAULT ‘No tiene’.
PAGO:

• COD_PAGO: INTEGER NOT NULL. • NRO_CREDITO_PAGO: VARCHAR(50). • TASA_INTERES_PAGO: INTEGER WITH DEFAULT 0. • NRO_CUOTA_PAGO: INTEGER WITH DEFAULT 1. • MONTO_IVA_PAGO: DOUBLE WITH DEFAULT 0. • INTERES_PAGO: DOUBLE WITH DEFAULT 0. • CAPITAL_PAGO: DOUBLE WITH DEFAULT 0. • OBSERVACIONES_PAGO: VARCHAR(500) WITH DEFAULT ‘No tiene’. • FECHA_PAGO: DATE. • CONCEPTO_PAGO: VARCHAR(10) WITH DEFAULT ‘Credito’. • NRO_TARJETA_PAGO: VARCHAR(50) WITH DEFAULT ‘No tiene’. • MONEDA_PAGO: VARCHAR(50) WITH DEFAULT ‘Pesos’.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

151

• FECHA_VENC_TARJETA_PAGO: DATE. • IMPORTE_TOTAL_PAGO: DOUBLE WITH DEFAULT 0. • IMPORTE_TARJETA_PAGADO: DOUBLE WITH DEFAULT 0. • SALDO_PAGO: DOUBLE WITH DEFAULT 0. • RESUMEN_TARJETA_PAGO: VARCHAR(50). • TIPO_PAGO: VARCHAR(25).
PERSONAL:

• COD_EMP: INTEGER NOT NULL. • NOMBRE_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • APELLIDO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • DOMICILIO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • TELEFONO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • FECHA_NAC_EMP: DATE NOT NULL. • ESTADO_CIVIL_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• FECHA_INGRESO_EMP: DATE NOT NULL. • CATEGORIA_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘Varios’. • NRO_LEGAJO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• CUIL_EMP: VARCHAR(15) NOT NULL WITH DEFAULT ‘No tiene’. • BASICO_EMP: DOUBLE NOT NULL. • NETO_EMP: DOUBLE NOT NULL. • EMAIL_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • LOCALIDAD_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • DNI: INTEGER NOT NULL WITH DEFAULT 0 . • ANTIGUEDAD_EMP: INTEGER NOT NULL WITH DEFAULT 0. • EMPRESA_EMP: VARCHAR(50). • EDAD_EMP: INTEGER. • CELULAR_EMP: VARCHAR(30). • PROVINCIA_EMP: VARCHAR(40).

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

152

PESAJE:

• COD_PESAJE: INTEGER NOT NULL. • FECHA_PESAJE: DATE. • RAZA_PESAJE: VARCHAR(50) WITH DEFAULT ‘No tiene’. • RODEO_PESAJE: VARCHAR(50). • EMPRESA_PESAJE: VARCHAR(50). • CANT_HEMBRAS_PESAJE: INTEGER WITH DEFAULT 0. • CANT_MACHOS_PESAJE: INTEGER WITH DEFAULT 0. • CANT_TOTAL_PESAJE: INTEGER WITH DEFAULT 0. • PESO_TOTAL_PESAJE: DOUBLE WITH DEFAULT 0. • PESO_PROMEDIO_PESAJE: DOUBLE WITH DEFAULT 0. • OBSERVACION: VARCHAR(30).
PRENIEZ:

• COD_PRENIEZ: INTEGER NOT NULL. • FECHA_PRENIEZ: DATE. • CATEGORIA_PRENIEZ: VARCHAR(20). • EMPRESA_PRENIEZ: VARCHAR(20). • OBSERVACION_PRENIEZ: VARCHAR(50). • NRO_CARAVANA_PRENIEZ: BIGINT. • EDAD_PRENIEZ: INTEGER. • MES_PRENIEZ: INTEGER.
PROVEEDOR:

• COD_PROV: INTEGER NOT NULL. • NOMBRE_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • CUIT_PROV: VARCHAR(20) NOT NULL WITH DEFAULT ‘No tiene’. • TELEFONO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • EMAIL_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • DOMICILIO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • LOCALIDAD_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

153

• NOMBRE_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• APELLIDO_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT
‘No tiene’.

• TELEFONO_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT
‘No tiene’.

• EMAIL_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• RUBRO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • DESC_PROV: VARCHAR(500) NOT NULL WITH DEFAULT ‘No tiene’. • PROVINCIA_PROV: VARCHAR(30).
ROLLO:

• COD_ROLLO: INTEGER NOT NULL. • FECHA_ROLLO: DATE. • CAMPO_ROLLO: INTEGER. • HA_ROLLO: VARCHAR(20) WITH DEFAULT ‘No tiene’. • CANT_ROLLO: INTEGER WITH DEFAULT 0. • OPERADOR_MAQ_ROLLO: INTEGER. • MAQ_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’. • ESPECIE_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’. • TIPO_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’. • CLIENTE_ROLLO: INTEGER WITH DEFAULT 0. • PRECIO_ROLLO: DOUBLE WITH DEFAULT 0. • PORCENTAJE_ROLLO: DOUBLE WITH DEFAULT 0. • EMPRESA_ROLLO: VARCHAR(100) WITH DEFAULT ‘No tiene’. • LOTE_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’. • COSTO_HA_ROLLO: DOUBLE WITH DEFAULT 0.0. • COSTO_OTRO_ROLLO: DOUBLE WITH DEFAULT 0.0. • COSTO_TOTAL_ROLLO: DOUBLE WITH DEFAULT 0.0. • IMPORTE_TOTAL: DOUBLE. • OPERADOR2_MAQ_ROLLO: INTEGER WITH DEFAULT 0.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

154

• LOTE_NOM_ROLLO: VARCHAR(50) WITH DEFAULT ‘’.
SIEMBRA:

• COD_SIEMBRA: INTEGER NOT NULL. • FECHA_SIEMBRA: DATE. • EMPRESA_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • CULTIVO_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • MAQUINA_SIEMBRA: INTEGER. • OPERADOR_MAQ_SIEMBRA: INTEGER. • CAMPO_SIEMBRA: INTEGER. • CAMPO_TERC_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • LOTE_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’. • SUPERFICIE_SIEMBRA: DOUBLE WITH DEFAULT 0. • KG_HA_SIEMBRA: DOUBLE WITH DEFAULT 0. • SEMILLA_METRO_SIEMBRA: INTEGER WITH DEFAULT 0. • CANT_HA_SIEMBRA: INTEGER WITH DEFAULT 0. • COSTO_HA_SIEMBRA: DOUBLE WITH DEFAULT 0. • COSTO_TOTAL_SIEMBRA: DOUBLE WITH DEFAULT 0 . • TIPO_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘Propia’. • PRECIO_HA_SIEMBRA: DOUBLE WITH DEFAULT 0. • PRECIO_TOTAL_SIEMBRA: DOUBLE WITH DEFAULT 0. • CLIENTE_SIEMBRA: INTEGER. • VAR_HIBRIDO_SIEMBRA: VARCHAR(100). • TIPO_FERTILIZANTE_SIEMBRA: VARCHAR(100). • FERTILIZANTE_KG_HA_SIEMBRA: DOUBLE. • OPERADOR2_MAQ_SIEMBRA: INTEGER NOT NULL WITH DEFAULT
0.

• LOTE_NOM_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘’.
STOCK:

• COD_STOCK: INTEGER NOT NULL. • EMPRESA_STOCK: VARCHAR(50).

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

155

• CULTIVO_STOCK: VARCHAR(50). • FECHA_STOCK: DATE NOT NULL. • CANT_TN_STOCK: DOUBLE NOT NULL.
TACTO:

• COD_TACTO: INTEGER NOT NULL. • FECHA_TACTO: DATE. • CATEGORIA_TACTO: VARCHAR(20). • EMPRESA_TACTO: VARCHAR(20). • OBSERVACION_TACTO: VARCHAR(50). • CANT_PRENIADAS_TACTO: INTEGER. • CANT_VACIAS_TACTO: INTEGER. • CANT_TOTAL_TACTO: INTEGER. • PORC_PRENIEZ_TACTO: DOUBLE. • COSTO_CABEZA_TACTO: DOUBLE. • COSTO_TOTAL_TACTO: DOUBLE.
TARJETA:

• COD_TARJETA: INTEGER NOT NULL. • NRO_TARJETA: VARCHAR(20) NOT NULL WITH DEFAULT ‘0’. • NOMBRE_TARJETA: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.

• BANCO_TARJETA: INTEGER NOT NULL WITH DEFAULT 0. • TIPO_TARJETA: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’. • FECHA_VENC_TARJETA: DATE NOT NULL. • OBSERVACIONES_TARJETA: VARCHAR(500) NOT NULL WITH DEFAULT
‘No tiene’.

• TITULAR_TARJETA: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’. TRASLADOS:

• COD_TRASLADO: INTEGER NOT NULL.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

156

• COSECHA_TRASLADO: INTEGER. • CARTA_TRASLADO: VARCHAR(100) WITH DEFAULT ‘’. • KG_EQUIPO_TRASLADO: DOUBLE WITH DEFAULT 0. • PROPIETARIO_EQUIPO_TRASLADO: VARCHAR(100) WITH DEFAULT
‘’.

• PATENTE_EQUIPO_TRASLADO: VARCHAR(50) WITH DEFAULT ‘’. • DESTINO_TRASLADO: VARCHAR(50) WITH DEFAULT ‘’. • EMPRESA_TRASLADO: VARCHAR(50). • FECHA_TRASLADO: DATE. • OTRO_DESTINO_TRASLADO: VARCHAR(50).
USUARIO:

• NRO_USUARIO: INTEGER NOT NULL. • NOMBRE_USUARIO: VARCHAR(20) NOT NULL. • CLAVE: VARCHAR(10) NOT NULL. • AREA: INTEGER NOT NULL WITH DEFAULT 0.
VACUNA:

• COD_VACUNA: INTEGER NOT NULL. • FECHA_VACUNA: DATE. • EMPRESA: VARCHAR(30). • PRODUCTO: VARCHAR(30). • ENFERMEDAD: VARCHAR(30). • GASTO_DOSIS: DOUBLE. • OTRO: DOUBLE. • GASTO_TOTAL: DOUBLE. • TERNEROS: INTEGER. • TERNERAS: INTEGER. • VAQUILLONAS: INTEGER. • NOVILLOS: INTEGER. • TOROS: INTEGER. • VACAS: INTEGER.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

157

• TOTAL_VACUNA: INTEGER.
VENTA:

• COD_VENTA: INTEGER NOT NULL. • FECHA_VENTA: DATE. • EMPRESA_VENTA: VARCHAR(50). • PRODUCTO_VENTA: VARCHAR(50). • DESTINATARIO_VENTA: VARCHAR(50). • CANTIDAD_VENTA: INTEGER. • PRECIO_VENTA: DOUBLE WITH DEFAULT 0. • TOTAL_VENTA: DOUBLE WITH DEFAULT 0. • TNTOTALES: DOUBLE. • TNVENDIDAS: DOUBLE. • TNSTOCK: DOUBLE. • IVA_VENTA: DOUBLE. • OBSERVACIONES_VENTA: VARCHAR(100). • FACTURA_VENTA: INTEGER WITH DEFAULT 0. • CULTIVO_VENTA: VARCHAR(30). • ESPECIE_VENTA: VARCHAR(30). • NRO_FACTURA_VENTA: VARCHAR(30). • TIPO_VENTA: VARCHAR(50). • OTRO_DESTINO_VENTA: VARCHAR(50). • MONEDA_VENTA: VARCHAR(25). La figura 8.26 de la página 158 visualiza la estructura de campos de algunas de las tablas que componen la base de datos AGRO, utilizada por el sistema aplicativo SAG.

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

158

Figura 8.26: Tablas de la Base de Datos SAG.

8.5.
8.5.1.

Ejemplos de Código Fuente Utilizados
Servlets y HTML embebido

A continuación se transcribe un ejemplo de Servlet con HTML embebido, utilizado por la aplicación, el mismo realiza una operación de alta de cosecha propia (AgregarCosechaPropia.java).
package cosecha; import java.io.IOException; import java.io.PrintWriter; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet;

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

159

import java.sql.SQLException; import java.sql.Statement; import java.text.NumberFormat; import javax.servlet.ServletConfig; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import utilitarios.SagHTML; public class AgregarCosechaPropia extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet { private static final long serialVersionUID = 1L; Connection conn; public void init(ServletConfig cf) throws ServletException { super.init(cf); try { Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); }catch (ClassNotFoundException e) { System.out.println(”Imposible encontrar el driver:” + e.getMessage()); } try { conn = DriverManager.getConnection(“jdbc:odbc:agro”); }catch (SQLException e) { System.out.println(“Imposible crear conexion:” + e.getMessage());

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

160

} public void destroy() { super.destroy(); try { conn.close(); }catch (SQLException e){ System.out.println(“Imposible cerrar conexion:” + e.getMessage()); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String usuario=request.getParameter(“usuario”); String fecha=request.getParameter(“fecha”); String empresa=request.getParameter(“empresa”); String cultivo=request.getParameter(“cultivo”); String maquina=request.getParameter(“maquina”); String operador=request.getParameter(“operador”); String operador2=request.getParameter(“operador2”); String campo=request.getParameter(“campo”); String cantidadha=request.getParameter(“cantidadha”); //Importes totales String importeha=request.getParameter(“importeha”); String importetotal=request.getParameter(“importetotal”); String lote=request.getParameter(“lotesel”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

161

String lotenom=request.getParameter(“lotenom”); String tncosechadas=request.getParameter(“tncosechadas”); String kgha=request.getParameter(“kgha”); PrintWriter out= response.getWriter(); NumberFormat NF = NumberFormat.getInstance(); NF.setMaximumFractionDigits(2); //2 decimales try{ Statement stm = conn.createStatement(); Statement stm1 = conn.createStatement(); Statement stm2 = conn.createStatement(); Statement stm3 = conn.createStatement(); Statement stm4 = conn.createStatement(); Statement stm5 = conn.createStatement(); stm.executeUpdate(“insert into cosecha(fecha_cosecha,empresa_cosecha, maquina_cosecha,operador_maq_cosecha,campo_cosecha,lote_campo_cosecha, kg_ha_cosecha,cant_ha_cosecha,importe_ha_cosecha,importe_total_cosecha, cultivo_cosecha,tipo_cosecha,tn_cosecha,operador2_maq_cosecha, lote_nom_cosecha) values(“‘+fecha+“’,“‘+empresa+”’,“+maquina+”, “+operador+”,“+campo+”,“‘+lote+”’,“+kgha+”, “+cantidadha+”,“+importeha+”, “+importetotal+”,“‘+cultivo+”’,‘Propia’,“+tncosechadas+”,“+operador2+”, “‘+lotenom+”’)”); stm5.executeUpdate(“insert into stock(empresa_stock,cultivo_stock,fecha_stock, cant_tn_stock) values(“‘+empresa+”’,“‘+cultivo+”’,“‘+fecha+”’, “+tncosechadas+”)”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

162

ResultSet rs1 = stm1.executeQuery(“Select * from maquina where cod_maq= “+maquina+””); ResultSet rs2 = stm2.executeQuery(“Select * from personal where cod_emp= “+operador+””); ResultSet rs3 = stm3.executeQuery(“Select * from campo where cod_camp= “+campo+”“); ResultSet rs4 = stm4.executeQuery(“Select * from personal where cod_emp= “+operador2+””); SagHTML.cabeceraGeneralHTML(out,“Agricultura“); SagHTML.barraMenuCabecera(out, “Opciones de”,“Agricultura”, “Cosecha Propia”); SagHTML.menuIzquierdoAgricultura(out,usuario); SagHTML.cuadroConsultar(out); SagHTML.cuadroBuscar(out); SagHTML.scriptGeneral(out); out.println(“<td width=18 align=left valign=top>&nbsp;</td>”); out.println(“<td align=left valign=top><table width=650 border=0 cellspacing=0 cellpadding=0>”); out.println(“<tr>”); out.println(“<td align=left valign=top><table width=650 border=0 cellspacing=0 cellpadding=0>”); out.println(“<tr>”); out.println(“<td align=left valign=top><table width=650 border=0 cellspacing=0 cellpadding=0>”); out.println(“<tr>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

163

out.println(“<td align=left valign=top><table width=300 border=0 cellspacing=0 cellpadding=0>”); out.println(“<tr>”); out.println(“<td class=menu_table style=border-bottom:1px dotted #bdbdbd; align=left valign=top colspan=2 width=344 >”); out.println(“<img src=images/home-icon.gif alt= width=11 height=10 class=home-icon /><span class=blue_title>”); out.println(“<SPAN class=red-titulo>Cosecha Propia</SPAN></span> <strong style=color:#000000;></strong> &nbsp;</td>”); out.println(“</TR>”); out.println(“<tr>”); out.println(”<td colspan=2 align=left valign=top ><SPAN class=blue_title> Los datos se han agregado exitosamente.</SPAN><BR>”); out.println(”</td>”); out.println(”</tr>”); out.println(”</TBODY>”); out.println(“</TABLE>”); out.println(“</TD>”); out.println(“</TR>”); out.println(“</TBODY>”); out.println(“</TABLE>”); out.println(“</TD>”); out.println(“</TR>”); out.println(“<TR>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

164

out.println(“<TD align=center valign=top >”); out.println(“<TABLE align=center border=0 >”); out.println(“<TBODY>”); out.println(“ <TR>”); out.println(“ <TD align=center colspan=2><a href=Propios? usuario=“+usuario+” ><IMG border=0 src=images/botones/propios.gif> </a>&nbsp;&nbsp;<a href=Terceros?usuario=“+usuario+” > <IMG border=0 src=images/botones/terceros.gif”); out.println(“ ></a>&nbsp;&nbsp;<a href=AgregarTraslados? usuario=“+usuario+” ><IMG border=0 src=images/botones/traslados.gif> </a></TD>”); out.println(“ </TR>”); out.println(“ <TR>”); out.println(“<TD align=center colspan=2>”); out.println(“<TABLE border=0>”); out.println(“<TBODY>”); out.println(“ <TR>”); out.println(“ <TD colspan=5><FIELDSET><LEGEND align=center> <a href=Propios?usuario=“+usuario+” target=_self ><IMG border=0 src=images/botones/agregar.gif></a> <a href=ModificarCosechaPropia target=_self ><IMG border=0 src=images/botones/modificar.gif></a> <a href=EliminarCosechaPropia target=_self ><IMG border=0 src=images/botones/eliminar.gif></a></LEGEND>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

165

out.println(“ <TABLE border=0 align=center>”); out.println(“ <TBODY>”); out.println(“ <TR>”); out.println(“ <TD>”); out.println(“ <TABLE border=0>”); out.println(“ <TBODY><FORM name=formcosecha ACTION= METHOD=POST>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Fecha:</TD>”); out.println(“ <TD align=left class=red-titulo>“+fecha+”</TD>”); out.println(“ <TD align=left rowspan=5 valign=top>”); out.println(“ <FIELDSET><LEGEND class=red-titulo></LEGEND>”); out.println(“ <TABLE border=0>”); out.println(“ <TBODY>”); out.println(“<TR>”); out.println(“ <TD align=left class=blue_title>Tipo de Cultivo:</TD>”); out.println(“ <TD align=left class=red-titulo>“+cultivo+”</TD>”); out.println(“</TR>”); out.println(“ </TR>”); out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Cantidad de Hectáreas:</TD>”); out.println(“ <TD align=left>“+cantidadha+”&nbsp;ha.</TD>”); out.println(“ </TR>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

166

out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Toneladas Cosechadas:</TD>”); out.println(“ <TD align=left>“+tncosechadas+”&nbsp;Tn.</TD>”); out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Rinde:</TD>”); out.println(“ <TD align=left>“+kgha+”&nbsp;kg.</TD>”); out.println(“ </TR>”); out.println(“ </TBODY>”); out.println(“ </TABLE></FIELDSET>”); out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Empresa:</TD>”); out.println(“<TD align=left>“+empresa+”</TD>”); out.println(“</TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Nombre del Campo:</TD>”); while(rs3.next()){ out.println(“ <TD align=left>“+rs3.getString(“nombre_camp”)+”</TD>”); } out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Nro. de Lote:</TD>”); out.println(“ <TD align=left>“+lotenom+”</TD>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

167

out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD colspan=2><HR></TD>”); out.println(“ </TR>”); out.println(“<TR>”); out.println(“<TD align=left class=blue_title>Máquina (Modelo - Año):</TD>”); out.println(“<TD align=left>”); String numero=“”; while(rs1.next()){ numero = rs1.getString(“cod_maq”); out.println(“ “+rs1.getString(“modelo_maq”)+”, “+rs1.getString(“anio_maq”)+””); } rs1.close(); out.println(“ </TD>”); out.println(“ <TD align=left rowspan=3 valign=top>”); out.println(“ <FIELDSET><LEGEND class=red-titulo></LEGEND>”); out.println(“ <TABLE border=0>”); out.println(“ <TBODY>”); out.println(“ <TR>”); out.println(“ <TD align=left class=blue_title>Importe por Hectárea:</TD>”); out.println(“ <TD align=left>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp ;&nbsp;$&nbsp;&nbsp;&nbsp;“+importeha+”</TD>”); out.println(“ </TR>”); out.println(“ <TR>”);

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

168

out.println(“ <TD colspan=2><HR></TD>”); out.println(“ </TR>”); out.println(“ <TR>”); out.println(“ <TD align=left class=red-titulo>Importe Total:</TD>”); out.println(“ <TD align=left class=red-titulo>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp ;&nbsp;$&nbsp;&nbsp;“+importetotal+”</TD>”); out.println(“ </TR>”); out.println(“ </TBODY>”); out.println(“ </TABLE></FIELDSET>”); out.println(“ </TD>”); out.println(“ </TR>”); out.println(“ </TR>”); out.println(“</TR>”); out.println(“<TR>”); out.println(“ <TD align=left class=blue_title>Operador 1:</TD>”); out.println(“ <TD align=left>”); while(rs2.next()){ out.println(“ “+rs2.getString(“apellido_emp”)+”, “+rs2.getString(“nombre_emp”)+””); out.println(“ </TD>”); out.println(“ </TR>”); out.println(“<TR>”); out.println(“ <TD align=left class=blue_title>Operador 2:</TD>”); out.println(“ <TD align=left>”); if(operador2.equals(0)){

CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN

169

out.println(“ ‘No Tiene”’); }else{ while(rs4.next()){ out.println(“ “+rs4.getString(“apellido_emp”)+”, “+rs4.getString(“nombre_emp”)+””); } out.println(“ </TD>”); out.println(“ </TR>”); out.println(“ </TBODY>”); out.println(“ </TABLE>”); out.println(“<TABLE class=ingresar-bg width=252 height=64>”); out.println(”<TBODY>”); out.println(“</table></td>”); out.println(“</tr>”); out.println(“ <TR>”); out.println(“ <TD colspan=2 align=right>”); out.println(“ <IMG border=0 src=images/atras.gif onClick=history.back()></TD>”); out.println(“ </TR>”); out.println(“</table></td>”); out.println(“</tr>”); SagHTML.cuerpoPrincipalFinal(out); SagHTML.finCuerpoPrincipal(out); SagHTML.finHTML(out); }catch(Exception e){ e.printStackTrace();

} }

Capítulo 9

Conclusiones
9.1. Conclusiones Acerca de las Tecnologías y Software Utilizados

Se ha podido comprobar las grandes ventajas de la utilización de tecnologías y software, tanto de base de datos como de desarrollo de aplicaciones, que soportan sistemas distribuidos multiplataforma. Esto ha resultado de gran utilidad al momento de desarrollar una aplicación con Eclipse y DB2 Express-C 9, bajo Windows XP service pack 3, utilizando Java 1.5, para implementarla en un entorno Windows, ha resultado sumamente sencilla, rápida y eficiente. El uso de Java se destaca en la Web y también sirve para crear todo tipo de aplicaciones distribuidas en la Red (locales, Intranet o Internet). En cuanto a las facilidades en el desarrollo de aplicaciones Java para entornos multiplataforma, se pudo apreciar que Eclipse puede ser usado desde la Intranet de una organización y/o desde la Internet, con lo cual el sistema resulta más eficiente, más flexible y adaptable al cambio y, además, con un soporte menos complejo. Con respecto al motor de bases de datos DB2 Express-C, se debe destacar la escalabilidad, integridad y seguridad permitiendo realizar respaldos en línea con distintos grados de granularidad sin que esto afecte la disponibilidad de acceso a los datos por parte de los usuarios; interfaces sencillas y entendibles, 171

completas, intuitivas y con diversos asistentes, permitiendo de esa manera una mejor comprensión en la utilización de la herramienta. Asimismo se pudo apreciar las facilidades del Scientific WorkPlace para escribir libros, por la calidad del producto obtenido, la automatización en el manejo de índices, la gestión dinámica de espacios, listas de figuras, de tablas, referencias dinámicas a objetos, bibliografia, etc. Se destaca la gran potencialidad de este conjunto de herramientas para el desarrollo de aplicaciones de gran porte y alta complejidad, para su acceso desde las Intranets de las organizaciones o desde la Internet. Se hace notar además que los usuarios a cargo de la aplicación, han manifestado su interés en el producto desarrollado, ya que se encuentra actualmente en uso por el establecimiento, debido a que pudieron observar las facilidades y buen desempeño de la aplicación y las sencillas interfaces gráficas; además de poder ser operado completamente desde la Intranet y/o Internet.

9.2.

Líneas Futuras de Acción

Se considera que las principales líneas futuras de acción derivadas del presente trabajo serían las siguientes: Desarrollar un esquema de seguridad más elaborado, incorporando criptografía en la gestión de las claves por la utilización de Internet de la aplicación. Desarrollar un manejo de activadores desde la base de datos, para automatizar la obtención de las copias de seguridad, haciendo más eficiente la aplicación. Incorporar links específicos a la meteorología, bolsa de cereales y otros para facilitar a los usuarios la toma de decisiones de las actividades rurales, como siembra, cosecha, ganadería, etc. Desarrollar ampliamente los módulos existentes, ya que actualmente solo se utiliza para la gestión de altas, bajas y modificación de información y consultas en base a la información ingresada a la aplicación. Incorporar la posibilidad que la aplicación pueda ser manipulada desde una Palm por el usuario final.

Bibliografía
[1] K. Rutledge. The Business Case for e-business. IBM Corp., 2000. [2] P. Gómez C. Solares. E. Castillo, A. Cobo. JAVA - Un Lenguaje de ˝ Programación Multiplataforma para Internet U 1/E. IBM Corp. [3] Daniela Momiroska Paul Read Nicholas Summers Virginia Totanes Calisto Zuzarte. Nagraj Alur, Peter Haas. DB2 UDB High Function Business Intelligence in e-business 1/E. IBM Corp., 2002. [4] Louisa Ford Paul Jud Kang Yong Ying. Whei-Jen Chen, Rav Ahuja. Up and Running with DB2 for Linux 1/E. IBM Corp., 2003. [5] G. Vasudeva G. Galambos. Patterns for e-business. J. Adams, S. Koushik. A Strategy for Reuse. IBM Corp., 2001. [6] David Kline Glen Johnson. Whei-Jen Chen, Angus Beaton. DB2 UDB Evaluation Guide for Linux and Windows 1/E. IBM Corp., 2003. [7] Alexandre H. Guerra Thomas Mitchell Francis Reddington. WheiJen Chen, Chris Fierros. DB2 UDB Exploitation of the Windows Environment 1/E. IBM Corp., 2003. [8] International Business Machines Corporation. WebSphere Studio Application Developer Version 4 for use with the Windows 2000 and Windows NT Operating System. IBM Press, 2002. ˝ [9] A. S. Tanenbaum. Sistemas Operativos Distribuidos U 1/E. Prentice Hall Hispanoamericana S.A. [10] D. L. La Red Martínez. Sistemas Operativos. Moglia SRL. ˝ [11] A. S. Tanenbaum. Sistemas Operativos Distribuidos U 1/E. Prentice Hall Hispanoamericana S.A. 173

Índice alfabético
agricultura modulo de, 121 agricultura y ganadería argentina, 1 agro-ganadería actualidad, 1 API interface de programación de aplicaciones, 32 API (Application Programming Interface), 41 aplicación descripción de la, 118 aplicación interactiva, 65 applet, 15 programa independiente, 21 seguridad, 24 applets, 21 concepto, 23 appletviewer visualizador de applets, 21 arrays, 60 AWT concepto, 63 interface gráfica de usuario, 63 bibliotecas de clases, 35 bifurcaciones, 52 if, 52 if else, 53 bloque try, catch, finally, 56 browser navegador, 23 bucles, 53 do while, 55 for, 54 while, 54 bytecodes serie de códigos, 16 C++ lenguaje de programación orientado a objetos, 11 C/C++, 50 código fuente, 158 Clase, 38 clase características, 57 clase en Java, 57 clase object, 59 clases de utilidad, 60 clase Arrays, 60 clases string y StringBuffer, 61 Double, 62 integer, 63 comentarios, 50 conclusiones, 171 Content-Type, 75 DB2 Express-C 9, 87 destroy, 78 doGet, 75 174

ÍNDICE ALFABÉTICO

175

doGet (), 78 doPost (), 78 Double, 62 métodos de la clase, 62

Eclipse entorno de desarrollo, 109 ejemplo de arrays, 61 garbage collection bifurcación if, 52 manejo automático de memoria, bifurcación if else, 53 17 bucle for, 54 bucle while, 54 herencia, 38, 41, 57 clase, 38 herencia múltiple, 39 comentario, 51 construcción de nombres de archivosHotJava, 28, 29 HTML, 20, 23 en Java, 69 lenguaje de marcación de hiperdo while, 55 texto, 23 interface, 39 HttpServletRequest, 75 línea compuesta por tres sentenHttpServletResponse, 75 cias, 50 método, 58 import, 52 matriz, 61 inialización de arrays, 60 operadores incrementales y relaINIT, 76 cionales, 48 instanciación e inicialización, 76 programa no portable, 66 integer, 63 sentencia return, 55 métodos de la clase, 63 encapsulación, 57 interface, 39 errores Internet Explorer, 27 gestión de, 56 Java, 19 Java, 36 errores de programación aplicaciones corporativas, 31 carga de drivers JDBC, 71 características, 12 entrada/salida por archivo, 73 conceptos básicos, 38 fuentes de caracteres, 73 Conceptos básicos de, 11 scheduling de los hilos de ejecuerrores de programación, 65 ción, 66 estructura general de un prograterminación de líneas, 72 ma, 36 uso de características de portabilintroducción a, 34 idad, 67 Jerarquía de clases en, 41

uso de directorios definidos, 68 estructuras de datos, 142 estructuras de programación, 50 evento, 64 sources, 64 eventos listeners, 64 expresión, 50

ÍNDICE ALFABÉTICO

176

lenguaje y código en, 34 limitaciones, 19 memoria, 17 orientado a objetos, 13 restricción de seguridad, 25 robustez de, 14 seguridad, 15 ventajas, 18 Java en browsers definición, 23 Java Standalone, 21 Java VM máquina virtual Java, 16 JavaSript, 20 javax.servlet.HttpServlet, 75 JDK, 51, 72 Java Development Kit, 15 JIT just in time compiler, 28 JSP compilación batch de, 81 modelos de, 78 procesadores, 79 JVM, 21 líneas longitud, 52 listener, 64

multithreading múltiples hilos de ejecución, 27 Nestcape Navigator, 26 Netscape, 11, 27 OO programación orientada a objetos, 35 OOP, 57 operadores, 45 aritméticos, 45 de asignación, 46 de concatenación de cadenas de caracteres, 48 incrementales, 46 precedencia de, 49 racionales, 47 unarios, 46 package, 40, 41 packages, 37 plugins, 19 polimorfismo, 57 POO programación orientada a objetos, 36 portabilidad, 16

return máquinas virtuales do while, 55 concepto, 26 RTTI métodos, 58 runtime type identification, 13 de la clase object, 59 de objeto, 58 sentencia, 50 módulos, 120 server-side, 76 malloc/free servicio soporte de memoria dinámica, 20 de demanda, 78 Microsoft, 27 servlet, 74 Microsoft Explorer, 26 ciclo de vida del, 76 multiplataforma, 16, 18 codificación de, 75

ÍNDICE ALFABÉTICO

177

desarrollo, 74 motor del, 76 servlets código fuente de, 158 Set-Cookie, 75 software, 40 String, 61 métodos de la clase, 62 string, 42 StringBuffer, 61 Sun, 11, 24 thread, 17 Tomcat Tomcat 5.0, 114 variable clasificación, 42 local, 43 miembro de una clase, 43 referencia, 42 variables miembro, 44 tipo primitivo, 42 visibilidad y vida de las, 44 Web aplicaciones, 81 WWW, 22

Sign up to vote on this title
UsefulNot useful