Aplicación Web Para la Gestión Agro-Ganadera.

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 . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
1
1
2
4
5
7
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 . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
11
12
13
18
19
19
20
20
21
21
23
23
26
28
29
29
30
31
. . . . .
. . . . .
de Java
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
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 . . . . . . . . . . . . . . . . . . .
3.4.
3.5.
3.6.
3.7.
3.8.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
36
36
38
38
38
39
40
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” . . .
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
Í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
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 . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
118
118
118
119
120
130
135
136
138
139
140
141
142
158
158
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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
173
Índice alfabético
174
Índice de figuras
1.1.
1.2.
1.3.
1.4.
1.5.
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. . . . . . . . . . .
. . . . . . .
3
Agricultura. 4
. . . . . . .
5
. . . . . . .
7
. . . . . . . 10
2.1.
2.2.
2.3.
2.4.
2.5.
2.6.
2.7.
Logo de Java. . . . . . . . . . . . . . . .
Arquitectura Cliente - Servidor. . . . . .
Bytecode y JVM. . . . . . . . . . . . . .
Netscape Navigator - Internet Explorer.
JIT - Just In Time. . . . . . . . . . . .
HotJava. . . . . . . . . . . . . . . . . . .
Clase Thread. . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
24
26
27
28
29
31
3.1.
3.2.
3.3.
3.4.
Herencia en Java. . . . . . . . .
Típicos Packages Predefinidos.
API de Java. . . . . . . . . . .
JDBC en Java. . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
41
42
71
4.1. Ciclo de Vida de un Servlet. . . . . . . . . . . . . . . . . . . . .
4.2. Requerimiento de un Archivo JSP. . . . . . . . . . . . . . . . .
4.3. Requerimiento de un Servlet. . . . . . . . . . . . . . . . . . . .
77
79
80
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
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. . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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
Í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
2.3.
23
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
3.3.
Conceptos Básicos
3.3.1.
Clase
38
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
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
44
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
3.4.2.
46
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
3.5.3.
52
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
3.7.
Clases de Mayor Utilidad
3.7.1.
Clase Arrays
60
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
3.7.4.
63
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.
El AWT (Abstract Windows Toolkit)
3.8.1.
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
3.8.4.
65
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
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 );
69
CAPÍTULO 3. EL LENGUAJE JAVA
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()];
70
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
4.1.2.
76
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
Figura 4.1: Ciclo de Vida de un Servlet.
77
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 conecR
R
o DB2 para i5/OS
es necesario ir a
tarse a servidores DB2 para z/OS
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.
R
Disponible en AIX
, 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.
R
Federation Server.
WebSphere
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
Figura 5.4: WebSphere Federation Server.
98
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
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.
103
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
Figura 5.9: Icono DB2 en Windows.
Figura 5.10: Editor de Comandos.
106
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
Figura 5.12: Salida de un Botón Show SQL.
108
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
Figura 8.19: Página Principal del Módulo Bancos.
137
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
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.
147
CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN
• 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).
148
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.
Ejemplos de Código Fuente Utilizados
8.5.1.
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
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());
159
CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN
}
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”);
160
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> </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>  </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
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>  <a href=Terceros?usuario=“+usuario+” >
<IMG border=0 src=images/botones/terceros.gif”);
out.println(“ ></a>  <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>”);
164
CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN
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+” ha.</TD>”);
out.println(“ </TR>”);
165
CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN
out.println(“ <TR>”);
out.println(“ <TD align=left class=blue_title>Toneladas Cosechadas:</TD>”);
out.println(“ <TD align=left>“+tncosechadas+” Tn.</TD>”);
out.println(“ </TR>”);
out.println(“ <TR>”);
out.println(“ <TD align=left class=blue_title>Rinde:</TD>”);
out.println(“ <TD align=left>“+kgha+” 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>”);
166
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
; $   “+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
; $  “+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 Ű 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 Ű 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 Ű 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
doGet (), 78
doPost (), 78
Double, 62
métodos de la clase, 62
175
uso de directorios definidos, 68
estructuras de datos, 142
estructuras de programación, 50
evento, 64
sources, 64
eventos
listeners, 64
expresión, 50
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
ÍNDICE ALFABÉTICO
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
176
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
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
177