Descripción: Desarrollo de Aplicaciones Móviles Web
1. Explique para qué es y para qué sirve un lenguaje de programación. 2. Realice un cuadro comparativo de las ventajas y desventajas que ofrecen las aplicaciones web en relación con las apl…Descripción completa
Descripción: El presente trabajo tiene como principal objetivo el análisis de vulnerabilidades en diferentes Aplicaciones Web y su solución.
Descripción completa
Exploración de los problemas particulares de seguridad que presentan las aplicaciones web, y enumeración de los distintos tipos de ataques o amenazas externas a las que se puede enfrentar. D…Descripción completa
examen
Este documento es un trabajo sobre Android realizado por tres alumnos para la asignatura de Programación Orientada a Objetos.
Descripción completa
En los últimos años se está dando un cambio de rumbo en la programación de aplicaciones informáticas: el paso de aplicaciones de escritorio a aplicaciones web. Esto responde por una parte a …Descripción completa
Prueba de Aplicaciones Web-pressmanDescripción completa
Informatica
Descripción completa
Descripción completa
Descripción completa
libro VII desarrollo de aplicaciones conjunto de libros uptDescripción completa
desarrollo de aplicacionesDescripción completa
Xyz DamDescripción completa
Descripción completa
UNIVERSIDAD PRIVADA TELESUP
1
UNIVERSIDAD PRIVADA TELESUP
Prefacio:
La asignatura es de naturaleza
teórico – práctico,
orientada al desarrollo del estudiante, con un avanzado nivel de habilidades en programación orientada al desarrollo de aplicaciones para la web, aplicando apropiadamente varios componentes y tecnología Java.
Definiendo; Una aplicación web es una aplicación a la que se accede a través de internet u otras redes similares como intranet, que no requiere instalación para los usuarios. Es decir, es una aplicación de software codificada en un lenguaje hecho para los navegadores web en la que es el navegador el que la ejecuta. Estas aplicaciones contienen elementos que permiten interactuar al usuario con la información que contienen.
Comprende cuatro Unidades de Aprendizaje: Unidad I: Fundamentos de la Tecnología Java. Unidad II: Tecnología JDBC (Java DataBase Connectivity). Unidad III: Patrón de Diseño MVC (Model – View - Controller). Unidad IV: Uso de Otros Componentes en el Desarrollo de Aplicaciones.
2
UNIVERSIDAD PRIVADA TELESUP
Estructura de los Contenidos
Fundamentos de la Tecnología Java
Fundamentos de POO en JAVA
Herencia y Polimorfismo
Estructuras de Datos Dinámicas (Java Collection
Tecnología JDBC (Java Database Connectivity)
Patron de Diseño MVC (Model – View Controller).
Interfaces JDBC.
Servlet. Uso del Reporteador ITEXT.
Las Interfaces y Clases del JDBC.
Presentar el Contenido de una Tabla.
Pasos para Crear un Servlet
Modelo Vista Controlador (MVC).
Framework).
Manejo y Uso de Sesiones
Uso de Otros Componentes en el Desarrollo de Aplicaciones
La Interface Preparedstament y Callablestament.
Consulta de Datos – MVC.
Jfreechart.
Gráfico con Base de Datos.
JQUERY.
La competencia que el estudiante debe lograr al final de la asignatura es: “Conocer programas y componentes sistemáticos para el desarrollo de las aplicaciones web, cumpliendo los procesos adecuados que se recomiendan en el presente material”.
3
UNIVERSIDAD PRIVADA TELESUP
Índice del Contenido
I. PREFACIO II. DESARROLLO DE LOS CONTENIDOS UNIDAD DE APRENDIZAJE 1: FUNDAMENTOS DE LA TECNOLOGIA JAVA 1. Introducción a. Presentación y contextualización b. Competencia (logro) c. Capacidades d. Actitudes e. Ideas básicas y contenido 2. Desarrollo de los temas a. Tema 01: Fundamentos de POO en JAVA b. Tema 02: Herencia y Polimorfismo c. Tema 03: Estructuras de Datos Dinámicas (Java Collection Framework). d. Tema 04: Manejo y Uso de Sesiones 3. Lecturas recomendadas 4. Actividades 5. Autoevaluación 6. Resumen UNIDAD DE APRENDIZAJE 2: TECNOLOGÍA JDBC (JAVA DATABASE CONNECTIVITY) 1. Introducción a. Presentación y contextualización b. Competencia (logro) c. Capacidades d. Actitudes e. Ideas básicas y contenido 2. Desarrollo de los temas a. Tema 01: Interfaces JDBC b. Tema 02: Las Interfaces y Clases del JDBC c. Tema 03: Presentar el Contenido de una Tabla d. Tema 04: La Interface Preparedstament y Callablestament 3. Lecturas recomendadas 4. Actividades 5. Autoevaluación 6. Resumen UNIDAD DE APRENDIZAJE 3: PATRON DE DISEÑO MVC (MODEL – VIEW - CONTROLLER). 1. Introducción a. Presentación y contextualización b. Competencia (logro) c. Capacidades d. Actitudes e. Ideas básicas y contenido 2. Desarrollo de los temas a. Tema 01: Servlet b. Tema 02: Pasos para Crear un Servlet c. Tema 03: Modelo Vista Controlador (MVC). d. Tema 04: Consulta de Datos – MVC. 3. Lecturas recomendadas 4. Actividades 5. Autoevaluación 6. Resumen UNIDAD DE APRENDIZAJE 4: USO DE OTROS COMPONENTES EN EL DESARROLLO DE APLICACIONES 1. Introducción a. Presentación y contextualización b. Competencia c. Capacidades d. Actitudes e. Ideas básicas y contenido 2. Desarrollo de los temas a. Tema 01: Uso del Reporteador ITEXT. b. Tema 02: Jfreechart. c. Tema 03: Gráfico con Base de Datos. d. Tema 04: JQUERY. 3. Lecturas recomendadas 4. Actividades 5. Autoevaluación 6. Resumen III. GLOSARIO IV. FUENTES DE INFORMACIÓN V. SOLUCIONARIO
a) Presentación y contextualización Java es la base para prácticamente todos los tipos de aplicaciones de red, además del estándar global para desarrollar y distribuir aplicaciones móviles y embebidas, juegos, contenido basado en web y software de empresa. Con más de 9 millones de desarrolladores en todo el mundo, Java le permite desarrollar, implementar y utilizar de forma eficaz interesantes aplicaciones y servicios.
b) Competencia Implementar páginas web dinámicas, con accesos a bases de datos, utilizando XML, con cualquier tipo de conexión de red entre cualquier sistema.
c) Capacidades 1. Conoce los principales fundamentos y funciones de POO en Java. 2. Reconoce las utilidades adecuadas de la herencia y polimorfismo. 3. Describe objetivamente las estructuras de datos dinámicos. 4. Analiza el manejo y uso adecuado de las sesiones.
d) Actitudes Pone en práctica cada uno de los procesos recomendados por Java. Incentiva el cumplimiento de las estructuras de los datos dinámicos.
e) Presentación de Ideas básicas y contenido esenciales de la Unidad: La Unidad de Aprendizaje 01: Fundamentos de la Tecnología Java, comprende el desarrollo de los siguientes temas:
TEMA 01: Fundamentos de POO en JAVA TEMA 02: Herencia y Polimorfismo TEMA 03: Estructuras de Datos Dinámicas (JAVA COLLECTION FRAMEWORK). TEMA 04: Manejo y Uso de Sesiones
6
UNIVERSIDAD PRIVADA TELESUP
Fundamentos de POO en JAVA
TEMA 1
Competencia: Conocer los principales fundamentos funciones de POO en Java.
7
y
UNIVERSIDAD PRIVADA TELESUP
Desarrollo de los Temas
Tema 01: Fundamentos de POO en Java CONCEPTOS BASICOS DE LA PROGRAMACION ORIENTADA A OBJETOS: Clase La clase es una plantilla o patrón a partir de la cual se crean muchos otros objetos similares, también se podría definir a una clase como la agrupación
de
objetos
que
poseen
características comunes.
Ejemplos:
Si Ud. tuviera que dibujar 30 mapas del Perú ¿Cómo los podría hacer de un modo muy rápido? Tendría que conseguir un molde o plantilla y a partir de éste podría crear los 30 mapas de un modo fácil y rápido. En este ejemplo el Molde o Patrón sería la Clase y cada uno de los mapas reproducidos vendrían ser los Objetos instanciados.
¿Qué clases puedes distinguir dentro de tu aula? En el aula existe la clase Alumnos, cada alumno vendría ser un objeto que se origina de esta clase. Otras clases podrían ser: Carpetas, Útiles, etc.
Como podemos darnos cuenta, los conceptos de la POO están en la vida diaria, y son estos conceptos los que se aplican al momento de programar aplicaciones informáticas.
Propiedades de la clase Las propiedades o atributos son las características descriptivas de una clase. Cuando definimos una propiedad especificamos su nombre y su tipo de dato.
8
UNIVERSIDAD PRIVADA TELESUP
Ejemplos: Propiedades de la clase Alumnos Apellidos
(Tipo de dato String)
Nombres
(Tipo de dato String)
Edad
(Tipo de dato int)
Talla
(Tipo de dato double)
Métodos en las clases Son las funcionalidades, acciones o habilidades de la clase. Los métodos son funciones que están asociadas a un objeto. Los métodos responden a la pregunta:
¿Qué es lo que es capaz de hacer la clase? Los nombres de los métodos generalmente están asociados a una acción o verbos. Al final del nombre de los métodos siempre se utilizarán paréntesis dentro de los cuales muchas veces es necesario enviar algunos datos, para que puedan realizarse los procesos.
Ejemplos: La clase Alumnos contiene los siguientes métodos: Estudiar () Hablar () DecirSuEdad( ) La clase plumones contiene los siguientes métodos: pintar() escribir() La clase calculadora contiene los siguientes métodos: Sumar(4,5) Restar(3,2) Multiplicar(4,3) Multiplicar(4,2)
9
UNIVERSIDAD PRIVADA TELESUP
Nota: -
Algunos métodos reciben entre los paréntesis: datos, los cuales sirven al método para realizar su tarea. Estos datos son conocidos como argumentos del método.
-
Algunos métodos retornan un dato como resultado de la acción, por ejemplo el método sumar(4,5) de la clase Calculadora, luego de realizar su acción devolverá un dato de respuesta el cual es el resultado de la suma: 9.
Objeto instanciado Los objetos instanciados son objetos creados a partir de una clase. Los objetos instanciados son copias de una clase. Esta acción de crear un objeto a partir de una clase se
llama
instanciar.
Todo
objeto
instanciado
hereda
automáticamente las propiedades y métodos de su clase base. Estados en objetos Cuando tenemos un objeto sus propiedades toman valores. Por ejemplo, cuando tenemos una Fracción, la propiedad numerador tomará un valor en concreto, como por ejemplo 1 y la propiedad denominador puede tomar el valor de 3. El valor concreto de una propiedad de un objeto se llama estado.
Para acceder a una propiedad o método, debemos especificar el objeto instanciado, luego colocaremos un punto y posteriormente el nombre de la propiedad o método que se ha heredado de su clase base. Ejemplo: obj.apellidos=”Torres”; obj.nombres=”Edwin”;
Ejemplos prácticos A continuación, mostraremos algunos ejemplos de clases con sus respectivas propiedades y métodos.
Con el siguiente gráfico, puedes tener un resumen de lo tratado en la presente unidad:
11
UNIVERSIDAD PRIVADA TELESUP
Programación orientada a objetos en java Creación de una clase en Java: Click Derecho sobre el paquete: New / Java Class public class Calculadora { public static void main(String args[]) {
} } //Fin de la clase
Atributos o propiedades de la clase Se deberán crear a nivel de la clase (debajo de public class) y cada una corresponderá a un tipo de dato. Ejemplo: La clase con sus propiedades public class Calculadora { // DEFINICION DE PROPIEDADES public String marca; public double precio; public String modelo; }
//Fin de la clase
12
UNIVERSIDAD PRIVADA TELESUP
Métodos de la clase Se deberán crear dentro de la clase, cada método devuelve un tipo de dato como resultado final (el cual puede ser int, double, String, boolean, etc), de no ser así el tipo de dato devuelto es void. Los métodos usan paréntesis para recibir algunos datos (argumentos) desde el exterior.
Ejemplo: Dato que devuelve
Argumentos de Entrada
public double sumar(double a, double b) {
double r; r=a+b; return r;
}
Nombre del método
Ejemplo: La clase con sus Propiedades y métodos: public class Calculadora { // DEFINICION DE PROPIEDADES
public String marca; public double precio; public String modelo; public double sumar(double a, double b) { double r; r=a+b; return r; //Retorna el resultado } public double restar(double a, double b) { double r; r=a-b; return r; }
13
UNIVERSIDAD PRIVADA TELESUP
public double multiplicar(double a, double b) { double r; r=a*b; return r; } public double dividir(double a, double b) {double r; if(b!=0) { r=a/b; } else {System.out.println("Resultado no determinado en N"); } return r; } public double dimetuprecio() { return precio; } }
//Fin de la clase
Métodos constructores Un método constructor es un método especial dentro de la clase, que lleva el nombre de la misma clase. Pueden existir uno o varios métodos constructores. Su función es de permitir el instanciamiento de objetos y al mismo tiempo introducir estados (datos) a todas o a algunas las propiedades del objeto instanciado.
Ejemplo: La misma clase anterior con 3 Métodos Constructores Nota: Si una clase posee varios métodos constructores, significa que tiene varias formas de instanciar un objeto. public class Calculadora { // DEFINICION DE PROPIEDADES public String marca; public double precio; public String modelo; public double sumar(double a, double b) { double r; r=a+b; return r; //Retorna el resultado }
14
UNIVERSIDAD PRIVADA TELESUP
public double restar(double a, double b) { double r; r=a-b; return r; } public double multiplicar(double a, double b) { double r; r=a*b; return r; } public double dividir(double a, double b) { double r; if(b!=0) { r=a/b; } else { System.out.println("Resultado no determinado en N"); } return r; } public double dimetuprecio() { return precio; } // EL METODO CONSTRUCTOR 1 // Permite el instanciamiento con el ingreso de los estados solo a 2 de // las propiedades del objeto instanciado public Calculadora(String ma, double p) { marca=ma; precio=p; } // EL METODO CONSTRUCTOR 2 - Permite el instanciamiento con el ingreso de los // estados solo a 3 de las propiedades del objeto // instanciado public Calculadora(String ma, double p, String mo) { marca=ma; precio=p; modelo=mo; }
// EL METODO CONSTRUCTOR 3 - Permite solo el instanciamiento public Calculadora() { } } //Fin de la clase
15
UNIVERSIDAD PRIVADA TELESUP
El método estático main Este método es el “Método principal” de la clase, es aquel que es invocado cuando ejecutamos la clase, si una clase no cuenta con el método main, es imposible ejecutar la clase. Instanciamiento de la clase Tal como vimos durante la semana anterior, instanciar significar crear un objeto a partir de una clase base, recordemos también que al instanciar un objeto, este hereda automáticamente propiedades y métodos de su clase.
public class Calculadora { // DEFINICION DE PROPIEDADES public String marca; public double precio; public String modelo; public double sumar(double a, double b) { double r; r=a+b; return r; //Retorna el resultado } public double restar(double a, double b) { double r; r=a-b; return r; }
public double multiplicar(double a, double b) { double r; r=a*b; return r; } public double dividir(double a, double b) {double r=0; if(b!=0) { r=a/b; } else {System.out.println("Resultado no determinado en N"); } return r; }
16
UNIVERSIDAD PRIVADA TELESUP
public double dimetuprecio() { return precio; } // EL METODO CONSTRUCTOR 1 // Permite el ingreso de los estados solo a 2 de // las propiedades del objeto instanciado public Calculadora(String ma,double p) { marca=ma; precio=p; } // EL METODO CONSTRUCTOR 2 - Permite el ingreso de los // estados solo a 3 de las propiedades del objeto // instanciado public Calculadora(String ma,double p, String mo) { marca=ma; precio=p; modelo=mo; } // EL METODO CONSTRUCTOR 3 - Permite solo el // instanciamiento public Calculadora() { } public static void main(String args[]) { //Creación de diferentes objetos instanciados //Se utilizará para cada instanciamiento a un método constructor diferente //Puede utilizarse cualquier método constructor para la instancia Calculadora c1=new Calculadora("CASIO",25.45); //Usa el constructor 1 Calculadora c2=new Calculadora("CITIZEN",32.99,"RS23"); //Usa el constructor 2 Calculadora c3=new Calculadora(); //Usa el constructor 3 //Usando la propiedades y métodos del 1er. obj. instanciado System.out.println("La marca de la calculadora 1 es : "+ c1.marca); System.out.println("La calculadora 1 suma 12+34 : "+ c1.sumar(12,34)); System.out.println("La calculadora 1 resta 12-34 : "+ c1.restar(12,34)); System.out.println("La calculadora 1 multiplica 12*34 : "+ c1.multiplicar(12,34)); System.out.println("La calculadora 1 divide 12/34 : "+ c1.dividir(12,34));
17
UNIVERSIDAD PRIVADA TELESUP
//Usando la propiedades y métodos del 2do. obj. instanciado System.out.println("Accedemos al precio de la calculadora 2 : "+ c2.precio); System.out.println("La calculadora 2 suma 2+-5 : "+ c2.sumar(2,-5)); System.out.println("La calculadora 2 nos dice su precio : "+ c2.dimetuprecio());
//Usando la propiedades y métodos del 3er. obj. instanciado c3.marca="Panasonic"; c3.precio=29.99; c3.modelo="RX123"; System.out.println("Accedemos al precio de la calculadora 3 : "+ c3.precio); System.out.println("La calculadora 3 suma 10+32 : "+ c3.sumar(10,32)); System.out.println("La calculadora 3 nos dice su precio : "+ c3.dimetuprecio()); } } //Fin de la clase
Invocación de una clase desde otros paquetes ¿Qué es una Paquete? Es una carpeta de java, dentro del cual podemos almacenar muchas clases, los paquetes en Java sirven para organizar nuestras clases, cada IDE tiene una forma distinta de crear paquetes. Proyecto Paquete 1 Paquete 2
Aquí tenemos dos paquetes, dentro de cada paquete tenemos una clase.
Cuando una clase es creada dentro de un paquete, debe llevar en la primera línea: el nombre del paquete. package Ejemplo1;
//Nombre del paquete
public class Calculadora { . .
Aquí va el contenido de la clase Calculadora
. }
18
UNIVERSIDAD PRIVADA TELESUP
Clase Anexo, creada en otro paquete package Ejemplo2;
//Nombre del paquete donde
se encuentra la clase import Ejemplo1.Calculadora; //Debe importarse la clase que está en otro paquete para que sea reconocida public class Anexo { public static void main(String args[]) { //Creación de los objetos instanciados Calculadora c5=new Calculadora("SANSUNG",25.45); //Usa el constructor 1 System.out.println("Multiplicando en la Calculadora 5: "+ c5.multiplicar(4,9)); } }
Creación de variables y métodos estáticos Variables Estáticas: Son aquellas variables que se declaran a nivel de la clase, se diferencian de las propiedades, porque para acceder a ellas no se requiere de una instancia, se puede acceder a estas variables directamente a través del nombre de la clase. Las variables estáticas conservan un mismo valor para toda la clase y no cuentan con estados (datos) diferentes en cada objeto instanciado.
Ejemplo del uso de variables estáticas en la Clase Calculadora: En este ejemplo se están creando dos variables
estáticas:
total: Variable
utilizada
para
acumular el precio de cada uno de los objetos instanciados cuenta : Variable utilizada para contar la cantidad de objetos instanciados Se usan las variables estáticas en cada una de los métodos constructores, para que de esta forma se acumule o cuente, cada vez que se produce una instancia. package Ejemplo1;
//Nombre del paquete
public class Calculadora {
19
UNIVERSIDAD PRIVADA TELESUP
// DEFINICION DE PROPIEDADES public String marca; public double precio; public String modelo; //DECLARACION DE VARIABLES ESTATICAS : Ámbito en toda la clase // comparten el mismo valor para todos los obj. Instanciados //son como si fueran variables globales public static double total; public static double cuenta; public double sumar(double a, double b) {
double r; r=a+b; return r; //Retorna el resultado
} public double restar(double a, double b) { double r; r=a-b; return r; } public double multiplicar(double a, double b) { double r; r=a*b; return r; } public double dividir(double a, double b) {double r=0; if(b!=0) { r=a/b; } else {System.out.println("Resultado no determinado en N"); } return r; }
public double dimetuprecio() { return precio; }
20
UNIVERSIDAD PRIVADA TELESUP
// EL METODO CONSTRUCTOR 1 // Permite el ingreso de los estados solo a 2 de // las propiedades del objeto instanciado //Este método ocurrirá al método de la instancia public Calculadora(String ma,double p) { marca=ma; precio=p; total+=precio; // Es un acumulador, (es variable estática, su valor se mantiene en toda la clase) cuenta++;
// Es un contador, (es variable estática, su valor se mantiene en toda la clase)
}
// EL METODO CONSTRUCTOR 2 - Permite el ingreso de los // estados solo a 3 de las propiedades del objeto // instanciado //Este método ocurrirá al método de la instancia public Calculadora(String ma,double p, String mo) { marca=ma; precio=p; modelo=mo; total+=precio; // Es un acumulador, (es variable estática, su valor se mantiene en toda la clase) cuenta++;
// Es un contador, (es variable estática, su valor se mantiene en toda la clase)
}
// EL METODO CONSTRUCTOR 3 - Permite solo el // instanciamiento //Este método ocurrirá al método de la instancia public Calculadora() { total+=precio; // Es un acumulador, (es variable estática, su valor se mantiene en toda la clase) cuenta++;
// Es un contador, (es variable estática, su valor se mantiene en toda la clase)
} public static void main(String args[]) {
21
UNIVERSIDAD PRIVADA TELESUP
//Creación de los objetos instanciados //En cada instancia está invocándose a los métodos constructores Calculadora c1=new Calculadora("CASIO",25.45); //Usa el constructor 1 Calculadora c2=new Calculadora("CITIZEN",32.99,"RS23"); //Usa el constructor 2 Calculadora c3=new Calculadora(); //Usa el constructor 3 //Mostramos el valor guardado en cada una de las variables estáticas System.out.println("Totall de los 3 precios de las calculadoras : "+ Calculadora.total); System.out.println("Cantidad de calculadoras : "+ Calculadora.cuenta); } }
//Fin de la clase
Métodos Estáticos: Son aquellos métodos que pertenecen directamente a la clase y que para acceder a ellos no se requiere de una instancia, se puede acceder a estos métodos directamente a través del nombre de la clase. Ejemplo del uso de métodos estáticos en la Clase Calculadora: En este ejemplo se están creando dos métodos estáticos: totalizar() : Método utilizado para devolver la cantidad acumulada de todos los precios promediar() : Método utilizado para promediar
todos los precios de los objetos
instanciados package Ejemplo1;
//Nombre del paquete
public class Calculadora {
// DEFINICION DE PROPIEDADES public String marca; public double precio; public String modelo; //DECLARACION DE VARIABLES ESTATICAS : Ámbito en toda la clase // comparten el mismo valor para todos los obj. instanciados public static double total; public static double cuenta;
22
UNIVERSIDAD PRIVADA TELESUP
//CREACIÓN DEL METODO ESTATICO public static double totalizar() { return total; } //CREACIÓN DEL METODO ESTATICO public static double promediar() { double p; p=total/cuenta; return p; }
public double sumar(double a, double b) {
double r; r=a+b; return r; //Retorna el resultado
} public double restar(double a, double b) { double r; r=a-b; return r; }
public double multiplicar(double a, double b) { double r; r=a*b; return r; }
23
UNIVERSIDAD PRIVADA TELESUP
public double dividir(double a, double b) {double r=0; if(b!=0) { r=a/b; } else {System.out.println("Resultado no determinado en N"); } return r; } public double dimetuprecio() { return precio; }
// EL METODO CONSTRUCTOR 1 // Permite el ingreso de los estados solo a 2 de // las propiedades del objeto instanciado public Calculadora(String ma,double p) { marca=ma; precio=p; total+=precio; // Es un acumulador, es igual que decir total=precio+total cuenta++;
// Es un contador, es igual que decir cuenta=cuenta+1
}
// EL METODO CONSTRUCTOR 2 - Permite el ingreso de los // estados solo a 3 de las propiedades del objeto // instanciado public Calculadora(String ma,double p, String mo) { marca=ma; precio=p; modelo=mo; total+=precio; // Es un acumulador, es igual que decir total=precio+total cuenta++;
// Es un contador, es igual que decir cuenta=cuenta+1
}
24
UNIVERSIDAD PRIVADA TELESUP
// EL METODO CONSTRUCTOR 3 - Permite solo el // instanciamiento public Calculadora() { total+=precio; // Es un acumulador, es igual que decir total=precio+total cuenta++;
// Es un contador, es igual que decir cuenta=cuenta+1
}
public static void main(String args[]) { //Creación de los objetos instanciados Calculadora c1=new Calculadora("CASIO",25.45); //Usa el constructor 1 Calculadora c2=new Calculadora("CITIZEN",32.99,"RS23"); //Usa el constructor 2 Calculadora c3=new Calculadora(); //Usa el constructor 3 //INVOCACION DE LOS METODOS ESTATICOS System.out.println("El total del costo de las tres calculadoras es : " + Calculadora.totalizar()); System.out.println("El promedio del costo de las tres calculadoras es : " + Calculadora.promediar()); } }
//Fin de la clase
Uso de constantes: Las constantes son también variables estáticas que al ser declaradas reciben un valor, y luego de esto, no permiten que dicho valor sea modificado en tiempo de ejecución. Ejemplo: public static final double IGV=0.19; public static final String RAZONSOCIAL=”TecniSystem SRL”;
25
UNIVERSIDAD PRIVADA TELESUP
Aplicando la POO en JAVA A continuación explicaremos a través de ejemplos 5 maneras diferentes de plantear un mismo caso en la programación orientada a objetos. a.
Primera Forma: Usando métodos con argumentos de entrada
b.
Segunda Forma: Usando métodos sin argumentos de entrada
c.
Tercera Forma: Usando métodos sin retorno
d.
Cuarta Forma: Usando un solo método en la clase.
e.
Quinta Forma: Usando métodos estáticos
f.
Sexta Forma: Usando métodos y variables estáticas
Desarrollo de una caso práctico Enunciado: Calcular el promedio de un alumno y determinar su situación académica. 1RA FORMA: Usando métodos con argumentos de entrada. Lógica de Negocios – Paquete model package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion; //Metodos de la clase : Usamos argumentos de entrada para el proceso public double calcularPromedio(double pc1, double ep, double pc2, double ptp, double ef){ return (pc1+2*ep+2*pc2+2*ptp+3*ef)/10; } public String determinarSituacionAcad(double p){ String sa=""; if (p>=10.5) { sa="Aprobado"; } else { sa="Desaprobado"; } return sa; } //Método constructor public Alumno(){ } }
<% //Instancia del Objeto Alumno obj1=new Alumno(); //Entrada de datos double pc1=5; double ep=12; double pc2=14; double ptp=8; double ef=7; //Invocación a los métodos y pasamos los argumentos necesarios double p=obj1.calcularPromedio(pc1, ep, pc2, ptp, ef); String sa=obj1.determinarSituacionAcad(p); //Mostrar resultados out.println("Promedio final "+p+" "); out.println("Situacion academica "+sa); %>
2da forma: Usando métodos sin argumentos de entrada Lógica de Negocios – Paquete model package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion; //Propiedades de entrada de datos public double pc1,ep,pc2,ptp,ef; public double p; //Métodos de la clase, ya no usamos argumentos de entrada, en su lugar
27
UNIVERSIDAD PRIVADA TELESUP
//hemos creado propiedades de entrada public double calcularPromedio(){ return (pc1+2*ep+2*pc2+2*ptp+3*ef)/10; } public String determinarSituacionAcad(){ String sa=""; if (p>=10.5) { sa="Aprobado"; } else { sa="Desaprobado"; } return sa; } //Metodo constructor public Alumno(){ } } Lógica de Presentación – Carpeta View <%@page import="model.Alumno"%> <%@page contentType="text/html" pageEncoding="UTF-8"%> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> Demo 2
Demo2
<% //Instancia del Objeto (Nacimiento del objeto) Alumno obj1=new Alumno(); //Entrada de datos (Directo a las propiedades) – Cargamos el objeto obj1.pc1=5; obj1.ep=12; obj1.pc2=14; obj1.ptp=8; obj1.ef=7; //Invocación a los métodos obj1.p=obj1.calcularPromedio(); //La rpta es guardada en una propiedad String sa=obj1.determinarSituacionAcad(); //Mostrar resultados out.println("Promedio final "+obj1.p+" "); //Mostramos la propiedad out.println("Situacion academica "+sa); %>
28
UNIVERSIDAD PRIVADA TELESUP
3ra forma: Usando métodos sin valor de retorno Lógica de Negocios – Paquete model package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion; //Propiedades de entrada de datos public double pc1,ep,pc2,ptp,ef; //propiedad de entrada y salida public double p; //Propiedades de salida public String sa; //Métodos – sin retorno de respta – La respta la guardamos en una propiedad public void calcularPromedio(){ this.p=(pc1+2*ep+2*pc2+2*ptp+3*ef)/10; } public void determinarSituacionAcad(){ if (this.p>=10.5) { this.sa="Aprobado"; } else { this.sa="Desaprobado"; } } //Metodo constructor public Alumno(){ } }
<% //Instancia del Objeto Alumno obj1=new Alumno();
29
UNIVERSIDAD PRIVADA TELESUP
//Entrada de datos (Directo a las propiedades) obj1.pc1=5; obj1.ep=12; obj1.pc2=14; obj1.ptp=8; obj1.ef=7; //Invocación a los métodos obj1.calcularPromedio();//La rpta se guarda internamente en una propiedad obj1.determinarSituacionAcad(); //Mostrar resultados out.println("Promedio final "+obj1.p+" "); //Mostramos la propiedad out.println("Situacion academica "+obj1.sa); %>
4ta forma: Usando un solo método en la clase. Fusionamos todos los métodos. Las diversas respuestas se guardan en propiedades. Lógica de Negocios – Paquete model
package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion; //Propiedades de entrada de datos public double pc1,ep,pc2,ptp,ef; //propiedad de entrada y salida public double p; //Propiedades de salida public String sa; //Metodos de la clase public void procesar(){ this.p=(pc1+2*ep+2*pc2+2*ptp+3*ef)/10; if (this.p>=10.5) { this.sa="Aprobado"; } else { this.sa="Desaprobado"; } } //Metodo constructor public Alumno(){ } }
<% //Instancia del Objeto Alumno obj1=new Alumno(); //Entrada de datos (Directo a las propiedades) obj1.pc1=5; obj1.ep=12; obj1.pc2=14; obj1.ptp=8; obj1.ef=7; //Invocación a los métodos obj1.calcularPromedio();//La rpta se guarda internamente en una propiedad obj1.determinarSituacionAcad(); //Mostrar resultados out.println("Promedio final "+obj1.p+" "); //Mostramos la propiedad out.println("Situacion academica "+obj1.sa); %>
5ta forma: usando métodos estáticos. Método Estático: Es un método que se declara a nivel de la clase, no requiere de una instancia para ser invocado, los métodos estáticos pueden ser invocados a partir del nombre de la clase. . Lógica de Negocios – Paquete model package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion;
31
UNIVERSIDAD PRIVADA TELESUP
//Metodos de la clase public static double calcularPromedio(double pc1, double ep,double pc2, double ptp,double ef){ return (pc1+2*ep+2*pc2+2*ptp+3*ef)/10; } public static String determinarSituacionAcad(double p){ String sa=""; if (p>=10.5) { sa="Aprobado"; } else { sa="Desaprobado"; } return sa; } //Metodo constructor public Alumno(){ } }
<% //Entrada de datos a variables double pc1=5; double ep=12;
32
UNIVERSIDAD PRIVADA TELESUP
double pc2=14; double ptp=8; double ef=7; //Invocación a los métodos – Desde el nombre de la clase //No se requiere instancia double p=Alumno.calcularPromedio(pc1,ep,pc2,ptp,ef); String sa=Alumno.determinarSituacionAcad(p); //Mostrar resultados out.println("Promedio final "+p+" "); out.println("Situacion academica "+sa); %>
6ta forma: usando métodos y variables estáticos. Variable Estática: Este tipo de variables son variables declaradas a nivel de una clase, el valor de esta se mantiene a nivel de la clase, a diferencia de una propiedad cuyo valor está asociado a un objeto instanciado, en cada objeto instanciado, la misma propiedad tiene valores diferentes.
Lógica de Negocios – Paquete model package model; public class Alumno { //Propiedades de la clase public String nombres; public String apellidos; public String direccion; //variables estaticas de entrada public static double pc1,ep,pc2,ptp,ef; public static double p; //Metodos de la clase public static double calcularPromedio(){ return (pc1+2*ep+2*pc2+2*ptp+3*ef)/10; } public static String determinarSituacionAcad(){
33
UNIVERSIDAD PRIVADA TELESUP
String sa=""; if (p>=10.5) { sa="Aprobado"; } else { sa="Desaprobado"; } return sa; } //Metodo constructor public Alumno(){ } }
<% //No se requiere instanciada //Entrada de datos a variables estaticas Alumno.pc1=5; Alumno.ep=12; Alumno.pc2=14; Alumno.ptp=8; Alumno.ef=7; //Invocaciòn a los mètodos Alumno.p=Alumno.calcularPromedio(); String sa=Alumno.determinarSituacionAcad(); //Mostrar resultados out.println("Promedio final "+Alumno.p+" "); out.println("Situacion academica "+sa); %>
34
UNIVERSIDAD PRIVADA TELESUP
Herencia y
TEMA 2
Polimorfismo Competencia: Reconocer las utilidades adecuadas de la herencia y polimorfismo.
35
UNIVERSIDAD PRIVADA TELESUP
Tema 02: Herencia y Polimorfismo HERENCIA DE CLASES La herencia permite que se pueda definir nuevas clases basadas en clases existentes, lo
cual
facilita
re-utilizar
código
previamente
desarrollado. Si una clase deriva de otra (extends), ésta hereda todas sus propiedades y métodos. La clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados.
Java permite múltiples niveles de herencia, No obstante, no permite que una clase derive de varias (no es posible la herencia múltiple). Se pueden crear tantas clases derivadas de una misma clase como se quiera. Resumen: Creamos una nueva clase a partir de la Clase Padre. La Clase Hijo hereda métodos y Atributos de la Clase Padre. Adicionalmente Podemos añadir otros métodos o atributos a la clase hijo.
Padre
La Clase Hijo Extiende de la Clase Padre
Hijo
36
UNIVERSIDAD PRIVADA TELESUP
Para indicar que una clase deriva de otra se utiliza la palabra extends, como por ejemplo: public class Alumno extends Persona { ... }
En el ejemplo anterior, se está creando la clase Alumno la cual extiende (hereda) de la clase Persona. Por tanto la clase Alumno habrá heredado las propiedades y métodos de la clase Persona.
Todas las clases de Java creadas por el programador tienen una super-clase. Cuando no se indica explícitamente una super-clase con la palabra extends, la clase deriva de java.lang.Object, que es la clase raíz de toda la jerarquía de clases de Java. Como consecuencia, todas las clases tienen algunos métodos que han heredado de Object.
Ventajas y precaucaciones de su uso La principal ventaja del uso de herencia de clases es la reutilización de los métodos de clases base, lo cual impide que se repita el mismo código muchas veces dentro del desarrollo de una aplicación, y por otro lado favorece el mantenimiento de los programas, porque cualquier cambio que se realice en una clase base inmediatamente replica para todas las subclases que extienden de esta, lo cual ahorra el tiempo a la labor de la programación.
Al diseñar nuestras clases es fundamental que primero se diseñe adecuadamente un modelo inicial, utilizando metodologías basadas en el análisis y diseño de sistemas orientado a objetos, de no ser así nuestro diseño de clases con sus respectivas herencias podría ser inconsistente e inarticulado.
37
UNIVERSIDAD PRIVADA TELESUP
Ejercicio Práctico: Crear un conjunto de clases que represente los procesos en el sistema de personal, luego instancie la clase Alumno presencial e invoque los métodos y muestre las respuestas conseguidas El siguiente diagrama ilustra el modelo de clases que desarrollaremos en la lógica de negocios.
Lógica de negocios Ámbitos de Alcance Es el mecanismo que permite definir el tipo de nivel de acceso a la información de los objetos, (clases, métodos y propiedades). En Java los niveles de encapsulamiento están dados de la siguiente forma: public, private, protected y package. De esta forma se puede controlar el acceso hacia las clases, métodos y propiedades y evitar un uso inadecuado .
38
UNIVERSIDAD PRIVADA TELESUP
Veamos cómo funcionan estos diversos niveles de acceso en el siguiente caso práctico: 1. Creamos dos paquetes: Paquete m y paquete n 2. Dentro del paquete m, tenemos dos clases; La clase A y la Clase B y 3. En el paquete n, tenemos también dos clases: La clase C (es una clase que extiende de la clase B), y la clase D.
Ahora, ubiquémonos en la clase B, y veamos en el siguiente cuadro, los diferentes tipos de acceso de esta clase hacia las demás clases del mismo paquete y de los demás.
Concepto y niveles de acceso en java:
39
UNIVERSIDAD PRIVADA TELESUP
Explicación:
Si el nivel de encapsulamiento para la clase B es public, esta clase será accesible a todas las clases de su propio paquete y de los demás.
Si el nivel de encapsulamiento para la clase B es private, esta clase no será accesible para ninguna otra clase, ni del mismo paquete, ni de otros. Si el nivel de encapsulamiento para la clase B es protected, esta clase será accesible a todas las clases de su propio paquete y solo a las clases heredadas de otros paquetes.
Si el nivel de encapsulamiento para la clase B es package o default, esta clase será accesible a todas las clases de su propio paquete únicamente.
POLIMORFISMO: Las interfaces En Java una interfaz es un prototipo de clase que define la funcionalidad de un objeto pero no lo implementa.
Características de una interfaz: Los métodos de una interfaz deben ser abstractos. No representa a un objeto sino a un Grupo de Objetos. Por lo tanto no usan constructores, ni métodos estáticos, ni atributos de Objeto. (Excepto variables constantes de tipo FINAL) En este nivel no podemos garantizar como lo hace, pero si sabemos qué hace. Interfaz en Java Se debe reemplazar la palabra class por interface.
40
UNIVERSIDAD PRIVADA TELESUP
Ejemplo: A continuación estamos creando una interfaz de nombre Reproducible. public interface Reproducible { // Aquí deben indicarse los métodos abstractos // con los que se trabajarán }
Métodos abstractos Son utilizados dentro de una interfaz, solo muestran la funcionalidad del objeto, pero no incluyen la lógica del procedimiento (no hacen nada por ellos mismos).
Ejemplo: public void play();
Este es un método abstracto, no usa llaves (No tiene implementación) No tienen definido el Cómo, pero si el Qué
Herencia en interfaces • Para darle un uso práctico a la interfaz: Debemos crear una clase que herede de dicha interfaz, en la cual se detallará la funcionalidad de los métodos declarados en la interfaz. • ¿Cómo realizar dicha herencia? public class MP3 implements Reproducible { // Aquí debe implementarse el método play, al cual // se hizo mención de manera abstracta en la interfaz }
41
UNIVERSIDAD PRIVADA TELESUP
Ventaja del uso de las interfaces •
Se utiliza las interfaces cuando en el desarrollo de una aplicación, aún no sabemos la lógica de los métodos, pero si conocemos cuales serán las funcionalidades importantes.
•
Nos permite ocultar el código fuente de los métodos de nuestras clases, puesto que solo al cliente tendríamos que suministrarle la interfaz y su ejecutable, mientras que la lógica de nuestros métodos lo almacenaríamos en un servidor de acceso restringido.
•
Una clase puede implementar más de una interface, representando una forma alternativa de la herencia múltiple. A su vez, 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.
42
UNIVERSIDAD PRIVADA TELESUP
Estructuras de Datos Dinámicas
TEMA 3
Competencia: Describir objetivamente las estructuras de datos dinámicos.
43
UNIVERSIDAD PRIVADA TELESUP
Tema 03: Estructuras de Datos Dinámicas (Java Collection Framework).
DEFINICIÓN Y CARACTERÍSTICAS Resumiendo, son aquellas cuyo tamaño (longitud, número de elementos...) varía en tiempo de ejecución. Las más famosas son: Listas simplemente enlazadas (con y sin cabecera), Listas doblemente enlazadas (con y sin cabecera), Pilas, Colas, Árboles y Grafos.
Su tamaño y forma es variable (o puede serlo) a lo largo de un programa, por lo que se crean y destruyen en tiempo de ejecución. Esto permite dimensionar la estructura de datos de una forma precisa: se va asignando memoria en tiempo de ejecución según se va necesitando.
En java tenemos muchas clases que manejan diferentes estructuras dinámicas, entre las que podemos mencionar: Vector Enumeration HashTable Stack Set List ArrayList Dictonary Collection SortedSet LinkedList
44
UNIVERSIDAD PRIVADA TELESUP
HashTables Es una estructura de datos dinámica que almacena un grupo de objetos, cada elemento almacenado en el HashTable debe contar un key (Código único que identifique de manera singular a dicho elemento dentro de la estructura). Esta estructura es de tipo LIFO (Last Input – First Output), es decir el último en entrar es el primero en salir, al momento de almacenarse dentro de la estructura.
Crear un HashTable: HashTable lista1=new HashTable(); //Crea una HashTable con longitud 0 HashTable lista2=new HashTable(10); //Crea un HashTable con longitud inicial 10 HashTable lista3=new HashTable(100);//Crea un Hashtable con longitud inicial 100
Métodos de la clase HashTable:
45
UNIVERSIDAD PRIVADA TELESUP
Nota: Para trabajar con la estructura Hashtable es necesario importar lo siguiente:
Caso Practico 1
Realizar un programa demostrativo en consola en muestre como crear y visualizar un Hashtable. package dinamicas2; import java.util.*; public class Demo { public static void main(String[] args) { //Crear un hashTable Hashtable lista=new Hashtable(); //Almacenar datos dentro del Hashtable, se debe colocar un key (llave) lista.put(1,20.0); lista.put(2,12.5); lista.put(3,10.0); lista.put(4,14.3); //recorrer los elementos Enumeration e=lista.elements(); Double dato=null; while(e.hasMoreElements()){ dato=(Double) e.nextElement(); System.out.println(dato.doubleValue()); } //Crear un hashTable con datos de tipo Character Hashtable lista2=new Hashtable(); lista2.put(1,'c'); lista2.put(2,'a'); lista2.put(3,'s'); lista2.put(4,'a'); //recorrer los elementos Enumeration e2=lista2.elements(); Character dato2=null; while(e2.hasMoreElements()){ dato2=(Character) e2.nextElement(); System.out.println(dato2.charValue()); }
46
UNIVERSIDAD PRIVADA TELESUP
//Crear un hashTable con distintos tipos de datos Integer sueldo=new Integer(600); String apellidos="Alva"; Double descuento=new Double(58.25); Hashtable lista3=new Hashtable(); lista3.put("1",apellidos); lista3.put("2",sueldo); lista3.put("3",descuento);
Caso Práctico 2: Realizar una aplicación visual que nos permita realizar operaciones de edición con los elementos de un Hashtable.
47
UNIVERSIDAD PRIVADA TELESUP
Declaración global a nivel de la clase
public class frmIngreso extends javax.swing.JFrame { Hashtable lista=new Hashtable(); int c=0; Codificación de la caja de texto txtape (evento actionperformanced)
private void txtapeActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: c++; String ape=txtape.getText(); txtape.setText(ape); lista.put(String.valueOf(c),ape); txtape.setText(""); txtape.requestFocus(); }
Codificación del botón Buscar private void btnBuscarActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: String cod; cod=JOptionPane.showInputDialog("Ingrese codigo "); if(lista.containsKey(cod)){ JOptionPane.showMessageDialog(null, "El dato fue encontrado"); } else{ JOptionPane.showMessageDialog(null, "El dato no fue encontrado"); } }
La Clase Vector •
La clase Vector permite crear un arreglo dinámico que almacena objetos.
•
En un objeto de tipo vector se almacenan objetos únicamente (es decir, variables de tipos de datos no primitivos o de clases bases).
•
Para almacenar valores de tipo de datos primitivos, se debe utilizar un arreglo estático o hacer casting de los valores a su correspondiente representación de objetos.
•
Esta clase tiene muchos métodos implementados que facilitan el trabajo con arreglos: búsquedas, eliminación, inserción, expansión entre otras.
•
Un objeto de tipo vector, se puede redimensionar en tiempo de ejecución, si las celdas que definen se han ocupado.
•
Para ello, existe un atributo o propiedad que le indica al compilar, en cuántas posiciones se puede redimensionar el vector, cuando ya haya ocupado su capacidad máxima.
49
UNIVERSIDAD PRIVADA TELESUP
Creación de un Vector:
Vector v=new Vector (20,5); Crea un vector con un tamaño inicial de 20 elementos y con la posibilidad de incrementar su tamaño de 5 en 5. Vector v=new Vector (20); Crea un vector con un tamaño inicial de 20 elementos y con la posibilidad de incrementar su tamaño de 20 en 20. Vector v=new Vector (); Crea un vector con un tamaño inicial de 10 elementos y con la posibilidad de incrementar su tamaño de 10 en 10. Métodos de la clase Vector
Vector( ) Constructor: crea un vector inicialmente vacío void addElement(Object obj) Inserta el objeto especificado al final del vector void setElementAt(Object obj, int índice) Inserta el objeto especificado en el vector en la posición específicada Object remove(int índice) Elimina el objeto que se encuentra en la posición especificada boolean removeElement(Object obj) Elimina la primera ocurrencia del objeto especificado en el vector void removeElementAt(int índice) Elimina el objeto especificado en el índice del vector void clear( ) Elimina todos los objetos del vector boolean contains(Object obj) Regresa verdadero si el objeto dado pertenece al vector int indexOf(Object obj) Retorna el índice del objeto especificado. Regresa -1 si no fue encontrado el objeto Object elementAt(int indíce) Regresa el objeto del índice específicado boolean isEmpty( ) Regresa verdadero si el vector no contiene elementos int size( ) Regresa el número de elementos en el vector
50
UNIVERSIDAD PRIVADA TELESUP
Recorrer los elementos de un Vector Utilizando el indice de elemento: for(int i=0; i
Caso Práctico Elaborar una aplicación visual que almacene los datos de n alumnos (Código, Apellidos, Asignatura, Nota1, Nota2 y Nota3) en una estructura Vector y luego que los muestre en un JTable. Mostrar en el listado el promedio y la situación académica de cada alumno.
Formulario 1 (Ingreso de datos):
Formulario 2 (Listado de Datos)
51
UNIVERSIDAD PRIVADA TELESUP
Codificación del formulario1 Declaración Global a nivel de Formulario public class frmData extends javax.swing.JFrame { Vector v=new Vector(1);
Codificación del botón Grabar private void btngrabarActionPerformed(java.awt.event.ActionEvent evt) { Alumnos obj=new Alumnos(); //Guardar datos en el objeto obj.setCodigo(txtcod.getText()); obj.setApellidos(txtape.getText()); obj.setAsignatura(txtasi.getText()); obj.setNota1(Double.parseDouble(txtn1.getText())); obj.setNota2(Double.parseDouble(txtn2.getText())); obj.setNota3(Double.parseDouble(txtn3.getText())); obj.calcularPromedio(); obj.hallarSitAcad(); v.addElement(obj); //Insertarmos al obj dentro del vector limpiarcajas(); }
Codificación del botón VerReporte private void btnreporteActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: frmReporte fr=new frmReporte(); fr.setData(v); fr.show(); }
Codificación del formulario2 Declaración Global (A nivel de Formulario) Vector cabecera=new Vector(1); Vector data=new Vector(1); Codificación del combo (Evento ItemStateChanged) private void jComboBox1ItemStateChanged(java.awt.event.ItemEvent evt) { // TODO add your handling code here: //Conseguir el valor seleccionado String sa = (String) jComboBox1.getSelectedItem(); if(sa.equals("Aprobado")){ mostraraprobados(); } else{ mostrarDesaprobados(); } }
Método mostraraprobados void mostraraprobados(){ Enumeration e = data.elements(); Vector ndata = new Vector(); Vector nfila = null; while (e.hasMoreElements()) { Vector fila = new Vector(1); fila = (Vector) e.nextElement(); nfila = new Vector(); String pro=fila.elementAt(6).toString(); double pr=Double.parseDouble(pro);
}
if (pr >= 10.5) { for (int i = 0; i < fila.size(); i++) { nfila.addElement(fila.elementAt(i)); } //fin del for que recorre fila ndata.addElement(nfila); } //fin del if //fin del while que recorre a data DefaultTableModel dm = new DefaultTableModel(ndata, cabecera); jTable1.setModel(dm);
}
53
UNIVERSIDAD PRIVADA TELESUP
Método mostrarDesaprobados void mostrarDesaprobados(){ Enumeration e = data.elements(); Vector ndata = new Vector(); Vector nfila = null; while (e.hasMoreElements()) { Vector fila = new Vector(1); fila = (Vector) e.nextElement(); nfila = new Vector(); String pro=fila.elementAt(6).toString(); double pr=Double.parseDouble(pro);
}
if (pr < 10.5) { for (int i = 0; i < fila.size(); i++) { nfila.addElement(fila.elementAt(i)); } //fin del for que recorre fila ndata.addElement(nfila); } //fin del if //fin del while que recorre a data DefaultTableModel dm = new DefaultTableModel(ndata, cabecera); jTable1.setModel(dm);
almacenar un grupo de datos en un sólo objeto. Los arrays sirven bien para este propósito, pero algunas veces necesitamos incrementar o reducir dinámicamente el número de elementos del array, o hacer que contenga distintos tipos de datos.
Esto es común entre las aplicaciones como las tiendas online. Un cliente añade una mercancía a su carro de la compra, y detrás de la escena, los ítems son almacenados y eliminados automáticamente. Para esta clase de grupos de datos crecientes y menguantes, podemos usar la reciente clase ArrayList del paquete java.util.
Creación de un ArrayList: ArrayList al=new ArrayList(); Crea un array dinámico con un tamaño inicial 0, se va incrementando o decrementando automáticamente. ArrayList al=new ArrayList(5); Crea un array dinámico con un tamaño inicial 5, se va incrementando o decrementando automáticamente.
Métodos de la clase ArrayList
55
UNIVERSIDAD PRIVADA TELESUP
Recorrer los elementos de un ArrayList Utilizando el indice de elemento: Iterator i=al.iterator(); while(i.hasNext()) { System.out.print(i.next()+"\t"); }
Caso Práctico: Realizar una aplicación Visual Java que realice las principales operaciones de edición de datos en un ArrayList.
56
UNIVERSIDAD PRIVADA TELESUP
Codificación a nivel de Clase (Declaración Global) public class frmArrayList extends javax.swing.JFrame { ArrayList lista=new ArrayList(); Codificación de la caja de texto txtdato private void txtdatoActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: String dato; dato=txtdato.getText(); lista.add(dato); //Agrega el dato al ArrayList txtdato.setText(""); //Limpiar la caja txtdato.requestFocus(); //Enviar el cursor a la caja visualizar(); }
Codificación del Método visualizar() private void visualizar() { int c = 0; Iterator i = lista.iterator(); String cad = ""; while (i.hasNext()) { cad += "[" + c + "]" + " " + i.next() + "\n"; c++; } txtlista.setText(cad); }
Codificación del botón Modificar private void btnmodificarActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: String pos=JOptionPane.showInputDialog("Indique la posicion"); String dato=JOptionPane.showInputDialog("Indique el dato"); int p=Integer.parseInt(pos); lista.set(p,dato); visualizar(); }
57
UNIVERSIDAD PRIVADA TELESUP
Codificación del botón Eliminar private void btneliminarActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: int p=Integer.parseInt(JOptionPane.showInputDialog("Ingrese posicion")); lista.remove(p); visualizar(); }
Codificación del botón Buscar private void btnbuscarActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: String dato=JOptionPane.showInputDialog("Ingrese dato a buscar"); if(lista.contains(dato)){ JOptionPane.showMessageDialog(null, "El dato fue encontrado"); } else { JOptionPane.showMessageDialog(null, "El dato no fue encontrado"); } }
Codificación del botón Ordenar private void btnordenarActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: Collections.sort(lista); visualizar(); }
Codificación del botón Sortear private void btnordenar1ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: Collections.shuffle(lista); visualizar(); JOptionPane.showMessageDialog(null, "El ganador es: "+lista.get(3)); }
58
UNIVERSIDAD PRIVADA TELESUP
Manejo y Uso de Sesiones
TEMA 4
Competencia: Analizar el manejo y uso adecuado de las sesiones.
59
UNIVERSIDAD PRIVADA TELESUP
Tema 04: Manejo y Uso de Sesiones ¿QUÉ ES UNA SESSION WEB? Es una instancia de trabajo del servidor web que corresponde a un usuario o cliente que se conecta.
¿Cuándo se da inicio a una sesión web? •
Cuando el usuario accede al sitio web a través de la URL.
¿Cuando finaliza una sesión web? •
Cuando se abandona el sitio web
•
Cuando se alcanza un tiempo de inactividad que es previamente establecido, en este caso la sesión es automáticamente eliminada. Si el usuario siguiera navegando se crearía una nueva sesión.
•
Se ha cerrado la sesión o reiniciado el servidor.
60
UNIVERSIDAD PRIVADA TELESUP
Variable de Session Una variable de sesión nos permite almacenar un dato y mantenerlo disponible para cualquier página de nuestra sesión web. Es comparable a una variable global que estaría disponible para cualquier página de nuestra aplicación. ¿Cómo crear una variable de Session? session.setAttribute("usu",usuario); ¿Cómo acceder a los datos de una variable de Session? (desde otra pagina o la misma página) String usuario=“”; usuario=(String)session.getAttribute("usu");
Manejo de Excepciones Durante el desarrollo de nuestros programas se pueden presentar diversos tipos de errores, los cuales se clasifican de la siguiente forma: a. Errores de Compilación: Son aquellos errores que se presentan en el momento de la compilación nuestro programa, el compilador informa el número de línea donde se produjo el error. Este tipo de error se produce generalmente cuando no cumplimos rigurosamente las reglas de sintaxis del Lenguaje de Programación. Algunos IDEs tiene el atributo Intelligent Sense con el cual automáticamente subrayan la línea de error mientras se escribe el código fuente.
b. Errores de Lógica: Este error se percibe cuando los resultados emitidos por nuestro programa son incorrectos e imprecisos, la razón de este tipo de error se debe al mal planteamiento de la lógica del programador. c. Errores en Tiempo de Ejecución: Este error se presenta imprevistamente durante el tiempo de ejecución (run-time) de nuestro programa, cuando éste no soporta una instrucción, y como resultado se cuelga o cierra. Estos tipos de errores deben ser controlados por la misma aplicación, y no deberían ocasionar que la ejecución colapse.
61
UNIVERSIDAD PRIVADA TELESUP
Precisamente las excepciones o Exceptions en Java controlan este último tipo de errores. Manejo de excepciones A
diferencia
de
otros
lenguajes
de
programación
orientados a objetos como C/C++, Java incorpora en el propio lenguaje la gestión de errores en tiempo de ejecución.
¿Cómo lo hace? Veamos: ¿Qué es una Exception? En el lenguaje Java, una Exception es un objeto que se genera automáticamente cuando se produce un error de ejecución, una excepción representa al error en sí, contiene información del error producido. 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, como por ejemplo, al 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 (indicando una nueva localización del fichero no encontrado).
Excepciones Estándar de Java: Los errores se representan mediante dos tipos de clases derivadas de la clase Throwable: Error y Exception. La siguiente figura muestra parcialmente la jerarquía de clases relacionadas con Throwable:
62
UNIVERSIDAD PRIVADA TELESUP
La clase Error está relacionada con errores de compilación, del sistema o de la JVM. De ordinario estos errores son irrecuperables y no dependen del programador ni debe preocuparse de capturarlos y tratarlos. La clase Exception tiene más interés. Dentro de ella se puede distinguir muchas clases derivadas que clasifican los diferentes tipos de errores que se pueden producir en Java. Ejemplo de algunas Excepciones:
NullPointerException : Exception producida cuando se hace referencia a una posición de una estructura de datos que no apunta a ningún dato. IndexOutBoundException: Exception producida cuando se hace referencia a un índice que sobrepasa la longitud de la estructura de datos. NegativeArraySizeException: Exception que se produce cuando se hace referencia a un número de índice negativo. EOFException: Exception que se produce cuando el puntero ha avanzado una posición posterior al último registro de una tabla.
Todas las excepciones por heredar de Throwable usan los métodos siguientes: 1. String getMessage() Extrae el mensaje asociado con la excepción. 2. String toString() Devuelve un String que describe la excepción. 3. void printStackTrace() Indica el método donde se lanzó la excepción. Un buen programa debe gestionar correctamente todas o la mayor parte de los errores que se pueden producir. Java para este fin utiliza la estructura try … catch y los Exceptions.
Estructura try … catch Cuando en un método se produce una situación anómala es necesario lanzar una excepción, la cual se desarrolla con la siguiente secuencia: 1. Se crea un objeto Exception de la clase adecuada. 2. Se lanza la excepción con la sentencia throw seguida del objeto Exception creado. Esta excepción deberá ser capturada (catch) y gestionada, para este fin Java nos brinda la estructura try… catch.
la posición "); n=Integer.parseInt(nn); char cc=cad.charAt(n); JOptionPane.showMessageDialog(null,"El carácter es: "+cc); } catch (Exception ex) { JOptionPane.showMessageDialog(null,ex.getMessage()); }
Explicación del ejemplo 1: La zona del try, incluye al código que está siendo controlado por posibles errores de ejecución. La zona del catch es la zona que atrapa al objeto Exception, en el caso de producirse un error; al producirse el error, se interrumpe la ejecución de la zona try y el control del programa se direcciona hacia la zona del try y visualizará un mensaje con la descripción del error.
La estructura try … catch puede utilizar varios bloques catch, en los cuales puede atrapar diversos tipos de Exceptions (errores), estos deben ser colocados desde lo más específico a lo más genérico. Esto permite personalizar la acción a realizar según el tipo de error producido. Veamos un segundo ejemplo:
64
UNIVERSIDAD PRIVADA TELESUP
Ejemplo 2: try { String cad="Universidad Privada Telesup"; int n=0; String nn=JOptionPane.showInputDialog("Ingrese la posición "); n=Integer.parseInt(nn); char cc=cad.charAt(n); JOptionPane.showMessageDialog(null,"El caracter es: "+cc); } catch (StringIndexOutOfBoundsException ex1) { JOptionPane.showMessageDialog(null,"Error: La posición esta fuera del rango de la cadena."); } catch (NumberFormatException ex2) { JOptionPane.showMessageDialog(null,"Error: El valor que Ud. ingresó no corresponde a un número."); } catch (Exception ex) { JOptionPane.showMessageDialog(null,ex.getMessage()); }
} Explicación del ejemplo 2: En este caso existen 3 bloques catch, cada uno de ellos atrapa un diferente tipo de error, según sea el caso. Nunca se realizará más de un bloque catch, solo se realizará el bloque que corresponda al error producido, los primeros dos bloques corresponden a errores especifico, el ultimo es un Exception genérico que corresponde a cualquier otro tipo de error. La cláusula finally: Esta cláusula es opcional y se coloca al final de la estructura, lo que se programe en este bloque se realizará de todos modos sea que se haya producido un error o no.
Ejemplo 3: try { String cad="Universidad Privada Telesup"; int n=0; String nn=JOptionPane.showInputDialog("Ingrese la posición "); n=Integer.parseInt(nn); char cc=cad.charAt(n); JOptionPane.showMessageDialog(null,"El caracter es: "+cc); } catch (StringIndexOutOfBoundsException ex1) { JOptionPane.showMessageDialog(null,"Error: La posición esta fuera del rango de la cadena."); } catch (NumberFormatException ex2)
65
UNIVERSIDAD PRIVADA TELESUP
{ JOptionPane.showMessageDialog(null,"Error: El valor que Ud. ingresó no corresponde a un número."); } catch (Exception ex) { JOptionPane.showMessageDialog(null,ex.getMessage()); } finally { JOptionPane.showMessageDialog(“Programa finalizado…”); } }
Clausula throws: Esta cláusula se puede acompañar en la declaración de un método, esto quiere decir que si dentro del método se produce un Exception (error), entonces dicho Exception será disparado hacia fuera (hacia el lugar desde donde se invocó al método, esta zona necesariamente debe estar dentro de un try … catch … ), tal como se muestra en el siguiente ejemplo: Ejemplo 4 public class Demo { public Demo() { } public void mostrar() throws Exception { String cad="Universidad Privada Telesup"; int n=0; String nn=JOptionPane.showInputDialog("Ingrese la posición "); n=Integer.parseInt(nn); char cc=cad.charAt(n); JOptionPane.showMessageDialog(null,"El carácter es: "+cc); }
public static void main(String args[]) { try { Demo obj=new Demo(); obj.mostrar(); } catch (Exception ex1) { JOptionPane.showMessageDialog(null,"Error: La posición esta fuera del rango de la cadena."); } } }
66
UNIVERSIDAD PRIVADA TELESUP
Lecturas Recomendadas
ESTRUCTURAS DE DATOS http://docencia.etsit.urjc.es/moodle_antiguo/file.php/90/Tema_2__Algoritmos_sobre_grafos_-_Estructuras_de_datos.pdf
PROGRAMACIÓN ORIENTADA A OBJETOS (POO) EN JAVA I: INTRODUCCIÓN http://eii.ucv.cl/pers/guidi/cursos/ti/Java-POO-1-Introduccion.pdf
Actividades y Ejercicios
1. Cree una aplicación web Java aplicando la POO utilizando las 3 formas aprendidas en clase. (1ra. Forma: Usando métodos con parámetros de entrada; 2da. Forma: Usando propiedades para los datos de entrada; 3ra. Forma: Usando propiedades para los datos de entrada y salida). Enunciado: Luego de ingresar la cantidad de horas trabajadas y el costo de pago por hora, calcular el salario mensual de un trabajador, sabiendo que dicho cálculo se genera en base a las horas mensuales trabajadas por el precio especificado por hora. Si se pasan de 192 horas mensuales trabajadas, las horas extraordinarias se pagarán a razón de 1.5 veces la hora ordinaria. Tenga en cuenta que todos los trabajadores obtienen una bonificación del 20% del salario mensual siempre y en cuando hayan laborado más de 100 horas al mes. Entradas: Horas Trabajadas y Costo Hora Salidas: Salario Mensual, Bonificación y Total a Percibir.
67
UNIVERSIDAD PRIVADA TELESUP
Autoevaluación
1) Es una plantilla o patrón a partir de la cual se crean muchos otros objetos similares. a. El método. b. La clase. c. El sistema. d. El algoritmo. e. El lenguaje de programación.
2) Son las características descriptivas de una clase: a. El diagrama de flujo. b. Las propiedades o atributos. c. Métodos. d. Instancias. e. Variables.
3) Los métodos responden a la pregunta: a. ¿Qué es lo que es capaz de hacer la clase? b. c. d. e.
¿Cuáles son los atributos de la clase? ¿Cuántas variables tiene la clase? ¿La clase es visible para todos los usuarios? ¿Hereda alguna propiedad de otra clase?
4) Son objetos creados a partir de una clase: a. Las variables. b. Las capsulas. c. Las constantes. d. Las consultas. e. Los Objetos instanciados. 5) Son copias de una clase: a. Los triggers. b. c. d. e.
Los Objetos instanciados. Las capas. Las condiciones. Los paquetes.
68
UNIVERSIDAD PRIVADA TELESUP
6) Para acceder a una propiedad o método, debemos especificar el objeto instanciado, luego colocaremos un ______ y posteriormente el nombre de la propiedad o método que se ha heredado de su clase base. a. Punto. b. Punto y coma. c. Paréntesis. d. Corchetes. e. Guion. 7) Es un método especial dentro de la clase, que lleva el nombre de la misma clase. a. Método array. b. Método pasedouble. c. Método constructor. d. Método joptionpane. e. Método get.
8) Es una carpeta de java, dentro del cual podemos almacenar muchas clases, los paquetes en Java sirven para organizar nuestras clases, cada IDE tiene una forma distinta de crear paquetes. a. Paquete. b. Clase. c. Sentencia. d. Constructor. e. CSS 9) Permite que se pueda definir nuevas clases basadas en clases existentes, lo cual facilita re-utilizar código previamente desarrollado: a. La clase. b. La Propiedad. c. La herencia. d. El constructor. e. El accionador. 10) En java tenemos muchas clases que manejan diferentes estructuras dinámicas, entre las que no se puede mencionar: a. Enumeration b. HashTable c. Stack d. Set e. Option Pane.
69
UNIVERSIDAD PRIVADA TELESUP
Resumen
UNIDAD DE APRENDIZAJE I:
En el diseño de la JCF las interfaces son muy importantes porque son ellas las que determinan las capacidades de las clases que las implementan. Dos clases que implementan la misma interfaz se pueden utilizar exactamente de la misma forma. Por ejemplo, las clases ArrayList y LinkedList disponen exactamente de los mismos métodos y se pueden utilizar de la misma forma.
La principal ventaja del uso de herencia de clases es la reutilización de los métodos de clases base, lo cual impide que se repita el mismo código muchas veces dentro del desarrollo de una aplicación, y por otro lado favorece el mantenimiento de los programas, porque cualquier cambio que se realice en una clase base inmediatamente replica para todas las subclases que extienden de esta, lo cual ahorra el tiempo a la labor de la programación.
HashTables: Es una estructura de datos dinámica que almacena un grupo de objetos, cada elemento almacenado en el HashTable debe contar un key (Código único que identifique de manera singular a dicho elemento dentro de la estructura).
Uno de los errores que se suele cometer es el de Compilación; los cuales son aquellos errores que se presentan en el momento de la compilación nuestro programa, el compilador informa el número de línea donde se produjo el error. Este tipo de error se produce generalmente cuando no cumplimos rigurosamente las reglas de sintaxis del lenguaje de programación.
70
UNIVERSIDAD PRIVADA TELESUP
71
UNIVERSIDAD PRIVADA TELESUP
Introducción
a) Presentación y contextualización: La conectividad de la base de datos de Java (JDBC, Java Database Connectivity) es un marco de programación para los desarrolladores de Java que escriben los programas que tienen acceso a la información guardada en bases de datos, hojas de cálculo, y archivos "planos". JDBC se utiliza comúnmente para conectar un programa del usuario con una base de datos por “detrás de la escena”, sin importar qué software de administración o manejo de base de datos se utilice para controlarlo.
b) Competencia: Comprende las principales funciones de las tecnologías Java (Java DataBase Connectivity.
c) Capacidades: 1. Utiliza adecuadamente las interfaces JDBC. 2. Reconoce y describe objetivamente cada una de las clases de las interfaces JDBC. 3. Conoce el proceso de presentación adecuada de los contenidos de una tabla. 4. Describe las propiedades y funcionalidades de la Interface Preparedstament y Callablestament.
d) Actitudes: Pone en práctica las recomendaciones relacionados a Java DataBase Connectivity. Muestra tolerancia ante las dificultades relacionadas a la tecnología JDBC.
e) Presentación de Ideas básicas y contenidos esenciales de la Unidad: La Unidad de Aprendizaje 02: Tecnología JDBC (Java DataBase Connectivity), comprende el desarrollo de los siguientes temas: TEMA 01: Interfaces JDBC. TEMA 02: Las Interfaces y Clases del JDBC. TEMA 03: Presentar el Contenido de una Ta. TEMA 04: La Interface Preparedstament y Callablest
72
UNIVERSIDAD PRIVADA TELESUP
Interfaces JDBC
TEMA 1
Competencia: Utilizar adecuadamente las interfaces JDBC.
73
UNIVERSIDAD PRIVADA TELESUP
Desarrollo de los Temas
Tema 01: Interfaces JDBC
INTRODUCCIÓN Java Database Connectivity (JDBC) es una interfase de acceso a bases de datos estándar SQL que proporciona un acceso uniforme a una gran variedad de bases de datos relacionales. JDBC también proporciona una base común para la construcción de herramientas y utilidades de alto nivel. El paquete actual de JDK incluye JDBC y el puente JDBC-ODBC. Estos paquetes son para su uso con JDK 1.x.
DEFINICIÓN DEL JDBC JDBC es el API para la ejecución de sentencias SQL. (Como punto de interés JDBC es una marca registrada y no un acrónimo, no obstante a menudo es conocido como “Java Database Connectivity”). Consiste en un conjunto de clases e interfases escritas en el lenguaje de programación Java. JDBC suministra un API estándar para los desarrolladores y hace posible escribir aplicaciones de base de datos usando un API puro Java.
Usando JDBC es fácil enviar sentencias SQL virtualmente a cualquier sistema de base de datos. En otras palabras, con el API JDBC, no es necesario escribir un programa que acceda a una base de datos Sybase, otro para acceder a Oracle y otro para acceder a Informix. Un único programa escrito usando el API JDBC y el programa será capaz de enviar sentencias SQL a la base de datos apropiada. Y, con una aplicación escrita en el lenguaje de programación Java, tampoco es necesario escribir diferentes aplicaciones para ejecutar en diferentes plataformas. La combinación de Java y JDBC permite al programador escribir una sola vez y ejecutarlo en cualquier entorno. Java, siendo
robusto,
seguro,
fácil
de
usar,
fácil
de
entender,
y
descargable
automáticamente desde la red, es un lenguaje base excelente para aplicaciones de base de datos.
74
UNIVERSIDAD PRIVADA TELESUP
FUNCIONES DEL JDBC 1. Establecer una conexión con una base de datos 2. Enviar una consulta SQL a la base de datos 3. Procesar los resultados de la consulta. El API JDBC del desarrollador de aplicaciones consta de dos partes, por un lado está el paquete java.sql, que contiene las clases e interfaces que permiten acceder a la funcionalidad básica del API JDBC. Este paquete forma parte de la edición estándar de la plataforma Java (J2SE), desde la versión 1.1 de ésta. Esta separata se centra en la funcionalidad de este paquete.
CARACTERÍSTICAS Y DRIVERS DEL JDBC Los Driver, también llamados Manejadores, son un conjunto de clases que implementan las clases e interfaces del API JDBC necesarias para que una aplicación Java pueda conectarse con una BD. Cuando los desarrolladores de una BD desean que esta pueda ser accesible mediante JDBC éstos deben implementar un manejador para esa base de datos; la misión del manejador será traducir comandos estándar del API JDBC al protocolo nativo de esa base de datos. Cada base de datos emplea un protocolo diferente de comunicación, protocolos que normalmente son propietarios. El uso de un manejador, una capa intermedia entre el código del desarrollador y la base de datos, permite independizar el código Java que accede a la BD del sistema de BD concreto a la que estamos accediendo, ya que en nuestro código Java emplearemos comandos estándar, y estos comandos serán traducidos por el manejador a comandos propietarios de cada sistema de BD concreto.
Si queremos cambiar el sistema de BD que empleamos lo único que deberemos hacer es reemplazar el antiguo manejador por el nuevo, y seremos capaces de conectarnos la nueva BD. Para garantizar que un manejador respeta el API JDBC existe un conjunto de pruebas que debe pasar el manejador para poderse considerar “JDBC CompliantTM”, estas pruebas (disponibles en http://java.sun.com/products/jdbc/download.html) nos garantizan que un manejador ha sido desarrollado siguiendo el API JDBC. En http://servlet.java.sun.com/products/jdbc/drivers se puede encontrar manejadores para prácticamente cualquier base de datos.
75
UNIVERSIDAD PRIVADA TELESUP
Tipos de manejadores: Hay 4 tipos de manejadores JDBC, que difieren en si, usan o no tecnología Java Pura, en su rendimiento y en la flexibilidad para cambiar de base de datos. Veamos cuales son:
a. Puente JDBC-ODBC (tipo1) ODBC es un API estándar semejante a JDBC, que permite que lenguajes como C++ accedan de un modo estándar a distintos sistemas de BD. Un manejador tipo puente JDBC-ODBC delega todo el trabajo sobre un manejador ODBC, que es quien realmente se comunica con la BD. El puente JDBC-ODBC permite la conexión desde Java a BD que no proveen manejadores JDBC. Fue muy útil cuando se creó el API JDBC, ya que muchas BD no disponían de manejadores JDBC, pero si de manejadores ODBC.
Empelado el puente JDBC-ODBC podía accederse a estas bases de datos empleando el API JDBC. Este tipo de manejador tiene dos desventajas: por un lado depende de código nativo, ya que el manejador ODBC no ha sido desarrollado en Java. Esto compromete la portabilidad de nuestro desarrollo. Por otro lado al emplear este tipo de manejador nuestra aplicación llama al gestor de manejadores JDBC, quien a su vez llama al manejador JDBC (puente JDBC-ODBC), quien llama al manejador ODBC, que es el que finalmente llama a la base de datos. Hay muchos puntos donde potencialmente puede producirse un fallo, lo cual hace que estos manejadores muchas veces sean bastante inestables.
76
UNIVERSIDAD PRIVADA TELESUP
El puente forma parte del jdk de SUN, esta en el paquete sun.jdbc.odbc. Inicialmente este tipo de manejador fue bastante útil por aliviar la carencia de manejadores JDBC. Hoy en día es el menos recomendado por limitar la portabilidad de la aplicación, al requerir código nativo, y por emplear tantas capas para la comunicación con la base de datos, lo que a veces hace que incrementa la inestabilidad de estos manejadores.
b. Manejador de API nativo (tipo2) Se basa en una librería escrita en código nativo para acceder a la base de datos. El manejador traduce las llamadas JDBC a llamadas al código de la librería nativa, siendo el código nativo el que se comunica con las bases de datos. La librería nativa es proporcionada por los desarrolladores de la BD. Estos manejadores son más eficientes y tienen menos puntos de fallo que el puente JDBC-ODBC ya que hay menos capas entre el código de la aplicación y la base de datos. Sin embargo siguen teniendo el problema de pérdida de portabilidad por emplear código nativo.
c. Manejador de JDBC-Net (tipo3) El manejador se comunica con un servidor intermedio que se encuentra entre el cliente y la base de datos. El servidor intermediario se encarga de traducir las al API JDBC al protocolo específico de la base de datos. No se requiere ningún tipo de código nativo en el cliente, por lo que la portabilidad de la aplicación está garantizada: el manejador es tecnología 100% Java. Además si el intermediario es capaz de traducir las llamadas JDBC a protocolos específicos de diferentes sistemas de BD podremos emplear un mismo manejador para comunicarnos con diferentes bases de datos.
77
UNIVERSIDAD PRIVADA TELESUP
Esto lo convierte en el manejador más flexible de todos. No obstante se trata de un driver complejo, ya que requiere la presencia de un midelware, una capa intermedia entre el cliente y la ase de datos, por lo que no es muy común emplearlo en arquitecturas simples, sino más bien en arquitecturas sofisticadas donde muchas veces entran en juego varias bases de datos distintas. API JDBC
d. Manejador de Protocolo Nativo (tipo4) El manejador traduce directamente las llamadas al API JDBC al protocolo nativo de la base de datos. Es el manejador que tiene mejor rendimiento, pero está más ligado a la base de datos que empleemos que el manejador tipo JDBC-Net, donde el uso del servidor intermedio nos da una gran flexibilidad a la hora de cambiar de base de datos. Este tipo de manejadores también emplea tecnología 100% Java.
78
UNIVERSIDAD PRIVADA TELESUP
Las Interfaces y Clases del JDBC
TEMA 2
Competencia: Reconocer y describir objetivamente cada una de las clases de las interfaces JDBC.
79
UNIVERSIDAD PRIVADA TELESUP
Tema 02: Las Interfaces y Clases del JDBC JDBC incluye un conjunto de interfaces y clases de que permiten el manejo de base de datos en Java, esta tecnología esta basada fundamentalmente en las siguientes interfaces: a. Driver
e. PreparedStatement
b. DriverManager
f.
c. Connection
g. ResultSet
CallableStatement
d. Statement
REGISTRO DE UN MANEJADOR Registrar un manejador no es más que cargar en memoria una clase que implementa el interfaz Driver, clase proporcionada por los desarrolladores de la base de datos. Existen tres formas de registrar un Driver: 1. Empleando el cargador de clases. Para ello empleamos, al igual que para cargar cualquier otra clase, el método forName(String clase) de la clase Class. Class.forName("com.mysql.Driver"); 2. Instanciando la clase que implementa el interfaz Driver. De este modo tendremos una referencia al Driver, pudiendo establecer la conexión directamente con él sin necesidad de emplear la clase DriverManager. La sintaxis es la misma que para instaciar cualquier otra clase: Driver driverPraMySQL = new org.gjt.mm.mysql.Driver();
3. Definir la propiedad jdbc.drivers. Podemos hacerlo de dos modos diferentes: a. Definiendo la propiedad jdbc.drivers en nuestra máquina virtual. La sintaxis es jdbc.drivers=nombreManejador1: nombreManejador2:… jdbc.drivers=gjt.mm.mysql.Driver:oracle.jdbc.driver.OracleDriver; b. Emplear la opción –D al invocar a la máquina virtual. Para ellos debemos arrancar nuestra aplicación con el comando java: Djdbc.drivers= nombreManejador1: nombreManejador2:… java -Djdbc.drivers=gjt.mm.mysql.Driver:oracle.jdbc.driver.OracleDriver;
80
UNIVERSIDAD PRIVADA TELESUP
INTERFAZ DRIVER Aunque es vital para establecer la conexión con la base de datos en la práctica el desarrollador de aplicaciones puede olvidarse de esta interfaz. Es responsabilidad del desarrollador del manejador proveer una clase que la implemente esta interfaz, y será responsabilidad del DriverManager llamar al método connect de los drivers registrados para intentar establecer la conexión con la base de datos. No obstante es posible crear un objeto tipo Driver, instanciando la clase desarrollada por el desarrollador del manejador, e invocar directamente a su método connect, obteniendo una conexión con la base de datos sin necesidad de emplear la clase DriverManager. De este modo tenemos más control sobre el Driver que estamos empleando en la conexión, cuando hemos registrado más de un driver, ya que no nos arriesgamos a que se establezca conexión con la BD con un driver distinto al que nosotros deseamos usar.
CLASE DRIVERMANAGER Como su nombre indica, esta clase es la gestora de los diversos drivers (manejadores) que existan en nuestra aplicación. Es posible que sea necesario que en una misma aplicación se tenga varios manejadores para acceder a varias bases de datos. Los métodos que más nos interesan de esta clase son: static Connection getConnection(String url); static Connection getConnection(String url, String user, String password). Estos métodos intentan establecer conexión con la base de datos que le indiquemos en el campo url, empleando para ellos todos los manejadores que hemos registrado. La diferencia entre un método y el otro, obviamente, es que en uno sólo se especifica la base de datos a la que nos queremos conectar, mientras que en el otro se indica también el nombre de usuario de la base de datos y su password. Más adelante explicaremos que es el objeto Connection que devuelven estos métodos. Lo que hace la clase DriverManager para intentar establecer conexión con la base de datos es invocar al método connect de la interface Driver, interface que como veremos deben implementar todos los manejadores. Realiza esta operación con todos los manejadores que tiene registrados, si el manejador devuelve null significa que no se ha podido conectar con la base de datos, y el gestor intenta de nuevo conectarse con otro manejador. Si consigue conectarse con un manejador no sigue intentándolo con el resto de los manejadores registrados, y si no consigue establecer la conexión con ningún manejador lanza una excepción tipo SQLException.
81
UNIVERSIDAD PRIVADA TELESUP
Sintaxis de los URL de JDBC Los URL (Uniform Resource Locator) de JDBC identifican una base de datos, y un protocolo de conexión a esta, de un modo unívoco. Toda URL de JDBC consta siempre de tres partes: protocolo:subprotocolo:subnombre. Ejemplo: "jdbc:odbc:usuarios"
Veamos cada una de las partes del URL: 1. Protocolo de la conexión. Siempre es jdbc. 2. Subprotocolo de la conexión. Identifica el tipo de mecanismo de conexión que emplearemos para acceder a la base de datos. Es imprescindible
especificarlo
para
que
el
DriverManager pueda saber que tipo de manejador debe emplear para crear la conexión. En el URL ejemplo el subprotocolo empleado para la conexión a la base de datos será ODBC, por lo que el DriverManager intentará establecer la conexión con todos los manejadores registrados que sean de tipo 1, puente JDBC-ODBC.
82
UNIVERSIDAD PRIVADA TELESUP
3. Subnombre, identifica la base de datos con la que queremos establecer una conexión. El subnombre es “usuarios”; será el sistema ODBC quien proporcione, a partir de ese nombre, el resto de la información necesaria para establecer la conexión con la base de datos. Sin embargo si empleamos otro protocolo puede ser necesario incluir la dirección de red del servidor como subnombre. Por ejemplo: protocolo:subprotocolo://servidor:puerto/subnombre "jdbc:microsoft:sqlserver://localhost:1433;pubsSQL;selectMethod=cursor”
Así por ejemplo la URL: jdbc:bdnet://javahispano.org:4040/usuarios emplearía el protocolo jdbc y un manejador de tipo JDBC-Net para conectarse a la hipotética base de datos “usuarios” a través del puerto 4040 de la máquina javahispano.org.
Métodos de la Clase DriverManager Todos los métodos que encontramos en esta clase son estáticos (No requieren instancia para poder utilizarlo) y se comentan brevemente a continuación:
Descripción Establece una conexión con la base de datos identificada por la URL de JDBC que se pasa por parámetros. Establece una conexión con la base de datos identificada por la URL de JDBC que se pasa por parámetros. Establece una conexión con la base de datos pero en su segundo parámetro especifica propiedades que posee el driver, como puede ser la base de datos, el usuario, la contraseña, etc. Estas propiedades se organizan en pares propiedad/valor. Escribe un mensaje en el flujo de actividad actual Establece el tiempo de espera que el driver utilizará para realizar una conexión.
INTERFAZ CONNECTION Representa una conexión con la base de datos. Permite crear objetos que representan consultas que se ejecutarán en la base de datos, y permite acceder a información sobre la base de datos y las posibilidades del manejador JDBC. En esta tabla recogemos los principales métodos de la interfaz Connection. Sobre muchos de ellos volveremos a hablar más adelante.
83
UNIVERSIDAD PRIVADA TELESUP
Método
Métodos de la Interfaz Connection Descripción
void close() boolean isClosed() boolean isReadOnly() PreparedStatement prepareStatement(String sql) PreparedStatement prepareStatement(String sql, int tipoResultSet, int tipoConcurrencia) void setReadOnly(boolean soloLectura)
Cierra una conexión, liberando todos los recursos asociados a la misma. Devuelve verdadero si la conexión está cerrada Devuelve true si la conexión es de sólo lectura Crea un objeto PreparedStatement que va a permitir enviar y ejecutar sentencias SQL parametrizadas a la base de datos correspondiente. Igual que el método anterior, pero permite especificar las características del ResultSet que se obtendrá a la hora de ejecutar el objeto PreparedStatement correspondiente. Establece si una conexión posee el modo de solo lectura o no, dependiendo del argumento de tipo booleano. Hace permanentes los cambios que se realizaron desde el ultimo commit o rollback. Crea un objeto de tipo Statement. Indica si está en modo auto-commit. Devuelve un objeto tipo DatabaseMetaData con meta información a cerca de la base de datos contra la cual se ha abierto esta conexión.. Crea un objeto CallableStatement para ejecutar procedimientos almacenados SQL en la BD. Crea un objeto PreparedStatement para ejecutar consultas SQL parametrizadas en la BD. Deshace todos los cambios realizados desde la última vez que se ejecutó commit o rollback Cierra una conexión, liberando todos los recursos asociados a la misma. Crea también una sentencia SQL pero generará en su ejecución un objeto ResultSet con unas características determinadas. Devuelve verdadero si la conexión está cerrada Devuelve true si la conexión es de sólo lectura Crea un objeto PreparedStatement que va a permitir enviar y ejecutar sentencias SQL parametrizadas a la base de datos correspondiente. Igual que el método anterior, pero permite especificar las características del ResultSet que se obtendrá a la hora de ejecutar el objeto PreparedStatement correspondiente. Establece si una conexión posee el modo de solo lectura o no, dependiendo del argumento de tipo booleano.
84
UNIVERSIDAD PRIVADA TELESUP
ENVIÓ DE SENTENCIAS SQL JDBC suministra tres clases para el envío de sentencias SQL. Estas clases son los siguientes: 1. Statement – Creada por el método createStatement. Un objeto Statement se usa para enviar sentencias SQL simples. 2. PreparedStatement
–
Creada
por
el
método
prepareStatement-
Un
objeto
PreparedStatement se usa para sentencias SQL que toman uno o más parámetros como argumentos de entrada (parámetros IN). PreparedStatement tiene un grupo de métodos que fijan los valores de los parámetros IN, los cuales son enviados a la base de datos cuando se procesa la sentencia SQL. Instancias de PreparedStatement extienden Statement y por tanto heredan los métodos de Statement. Un objeto PreparedStatement es potencialmente más eficiente que un objeto Statement porque este ha sido precompilado y almacenado para su uso futuro.
3. CallableStatement – Creado por el método prepareCall. Los objetos CallableStatement se usan para ejecutar procedimientos almacenados SQL – un grupo de sentencias SQL que son llamados mediante un nombre, algo parecido a una función - . Un objeto CallableStatement hereda métodos para el manejo de los parámetros IN de PreparedStatement, y añade métodos para el manejo de los parámetros OUT e INOUT.
INTERFACE STATEMENT Esta interfaz permite enviar instrucciones SQL a la base de datos. Podemos obtener un
objeto
que
implemente
esta
interfaz
a
partir
del
método
Statement
createStatement() de la interfaz Connection. Para enviar una consulta tipo SELECT se emplea el método executeQuery(String sql). Este método devuelve un objeto tipo ResultSet. Para enviar una instrucción tipo DELETE, UPDATE, INSERT o una instrucción DDL (Data Definition Language) se emplea executeUpdate(String sql). Mediante el método execute(String sql) podemos ejecutar cualquiera de los comandos anteriores.
Un objeto Statement se usa para enviar sentencias SQL a la base de datos. Actualmente hay tres tipos de objetos Statement, todos los cuales actúan como contenedores para la ejecución de sentencias en una conexión dada: Statement, PreparedStatement que hereda de Statement y CallableStatement que hereda de PreparedStatement.
85
UNIVERSIDAD PRIVADA TELESUP
Estas están especializadas para enviar tipos particulares de sentencias SQL, Un objeto Statement se usa para ejecutar una sentencia SQL simple sin parámetros. Un objeto PreparedStatement se usa para ejecutar sentencias SQL precompiladas con o sin parámetros IN; y un objeto CallableStatement se usa para ejecutar un procedimiento almacenados de base de datos. La interfase Statement suministra métodos básicos para ejecutar sentencias y devolver resultados. La interfase PreparedStatement añade métodos para trabajar con los parámetros IN; y la interfase CallableStatement añade métodos para trabajar con parameters OUT.
Creación de objetos Statement Una vez establecida la conexión con una base de datos particular, esta conexión puede usarse para enviar sentencias SQL. Un objeto Statement se crea mediante el método de Connection createStatement, como podemos ver en el siguiente fragmento de código. Connection con = DriverManager.getConnection(url, "sunny", ""); Statement stmt = con.createStatement(); La sentencia SQL que será enviada a la base de datos es alimentada como un argumento a uno de los métodos de ejecución del objeto Statement. Por ejemplo: ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2");
Ejecución de sentencias usando objetos Statement. La interfase Statement nos suministra tres métodos diferentes para ejecutar sentencias SQL, executeQuery, executeUpdate y execute. El método a usar esta determinado por el producto de la sentencia SQL El método executeQuery esta diseñado para sentencias que producen como resultado un único resultSet tal como las sentencias SELECT. El método executeUpdate se usa para ejecutar sentencias INSERT, UPDATE ó DELETE así como sentencias SQL DDL (Data Definition Language) como CREATE TABLE o DROP TABLE. El efecto de una sentencia INSERT, UPDATE o DELETE es una modificación de una o más columnas en cero o más filas de una tabla. El valor devuelto de executeUpdate es un entero que indica el número de filas que han sido afectadas (referido como update count). Para sentencias tales como CREATE TABLE o DROP TABLE, que no operan sobre filas, le valor devuelto por executeUpdate es siempre cero.
86
UNIVERSIDAD PRIVADA TELESUP
El método execute se usa para ejecutar sentencias que devuelven más de un ResultSet, más que un update count o una combinación de ambos. Todos los métodos que ejecutan sentencias cierran los objetos ResultSet abiertos como resultado de las llamadas a Statement. Esto quiere decir que es necesario completar el proceso con el actual objeto ResultSet antes de reejecutar una sentencia Statement. Debe notarse que la interfase PreparedStatement, que hereda los métodos de la interfase Statement, tiene sus propias versiones de los métodos executeQuery, executeUpdate y execute. Los objetos Statement en si mismos no contienen una sentencia SQL, por tanto debe suministrarse como un argumento a los métodos Statement.execute. Los objetos PreparedStatement no suministran una sentencia SQL como argumento a estos métodos puesto que ya tienen la sentencia precompilada. Los objetos CallableStatement heredan las formas de estos métodos de PreparedStatement. Usar un parametro de query con las versiones de los métodos de PreparedStatement o CallableStatement producirá una SQLException.
Realización de Statement Cuando una conexión está en modo auto-commit, las sentencias ejecutadas
son
„comitadas‟ o rechazadas cuando se completan. Una sentencia se considera completa cuando ha sido ejecutada y se han devuelto todos los resultados. Para el método executeQuery, que devuelve un único ResultSet, la sentencia se completa cuando todas las filas del objeto ResultSet se han devuelto. Para el método executeUpdate, un sentencia se completa cuando se ejecuta. En los raros casos en que se llama al método execute, de cualquier modo, no se completa hasta que los ResultSets o update counts que se generan han sido devueltos.
Algunos DBMS tratan cada sentencia en un procedimiento almacenado como sentencias separadas. Otros tratan el procedimiento entero como una sentencia compuesta. Esta diferencia se convierte en importante cuando está activo el modo auto-commit porque afecta cuando se llama al método commit. En el primer caso, cada sentencia individual es commitada. En el segundo, se commiten todas juntas.
87
UNIVERSIDAD PRIVADA TELESUP
Cerrar objetos Statement Los objetos Statement se cerrarán automáticamente por el colector de basura de Java (garbage collector). No obstante se recomienda como una buena práctica de programación que se cierren explícitamente cuando no sean ya necesarios. Esto libera recursos DBMS inmediatamente y ayuda a evitar potenciales problemas de memoria.
INTERFAZ RESULTSET Esta interfaz representa un conjunto de datos que son el resultado de una consulta SQL. La clase posee una serie de métodos XXX getXXX(int columna) y XXX getXXX(String columna) que permiten acceder a los resultados de la consulta (para la sintaxis correcta de estos métodos acudir al javadoc de la interfaz ResultSet). Para acceder a los distintos registros empleamos un puntero, que inicialmente apunta justo antes de la primera fila. Para desplazar el puntero empleamos el método next().
Un ResultSet contiene todas las filas que satisfacen las condiciones de una sentencia SQL y proporciona el acceso a los datos de estas filas mediante un conjunto de métodos get que permiten el acceso a las diferentes columnas de la filas. El método ResultSet.next se usa para moverse a la siguiente fila del ResultSet, convirtiendo a ésta en la fila actual. El formato general de un ResultSet es una tabla con cabeceras de columna y los valores correspondientes devueltos por la „query‟. Por ejemplo, si la „query‟ es SELECT a, b, c FROM Table1, el resultado tendrá una forma semejante a:
a -------12345 83472 83492
b --------Cupertino Redmond Boston
c -------CA WA MA
88
UNIVERSIDAD PRIVADA TELESUP
ESTABLECIENDO UNA CONEXIÓN JDBC Pasos necesarios para Establecer una Conexión JDBC 1. Importar las clases del paquete java.sql Para utilizar esta tecnología, debemos importar las clases del paquete: java.sql De la siguiente manera: package comercial; import java.sql.*; public class GestionBD { // Contenido de la clase
Importación necesaria para trabajar con JDBC
}
2. Registrar el Driver a utilizar en la clase DriverManager: Pasar el nombre del paquete donde se encuentra el JDBC package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); // Driver } catch(Exception e) { System.out.println("Error al Cargar el Driver"); } }}
Registrar
el
3. Abrir la conexión La forma común de establecer una conexión con una base de datos es llamar al método getConnection() de la clase DriverManager, a este método se le debe pasar como parámetro la URL de JDBC que identifica a la base de datos con la que queremos realizar la conexión. La ejecución de este método devolverá un objeto Connection que representará la conexión con la base de datos. La sintaxis general para realizar una conexión es la siguiente: Connection cn=DriverManager.getConnection(url);
89
UNIVERSIDAD PRIVADA TELESUP
Ejemplo: package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet String url="jdbc:odbc:datos"; // Se define la cadena de conexión // (nombre del ODBC:datos) String usuario=""; String password=""; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); cn=DriverManager.getConnection(url,usuario,password); } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); }} }
Abrir conexión
4. Definir el objeto Statement para el manejo de comandos. (Se requiere que la conexión está abierta) Ejemplo: package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet String url="jdbc:odbc:datos"; // Se define la cadena de conexión (nombre del // ODBC:datos) String usuario=""; String password=""; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); cn=DriverManager.getConnection(url,usuario,password); stmt=cn.createStatement(); // Se crea el comando Crear el objeto comando } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); }}}
90
UNIVERSIDAD PRIVADA TELESUP
5. Crear el esquema de datos (Objeto ResultSet) : A partir de la ejecución del comando Select. package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet String url="jdbc:odbc:datos"; // Se define la cadena de conexión // (nombre del ODBC:datos) String usuario=""; String password=""; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); cn=DriverManager.getConnection(url,usuario,password); stmt=cn.createStatement(); // Se crea el comando Crear el esquema de Datos rs=stmt.executeQuery("select * from Clientes"); } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); }} }
6. Visualizar el contenido del esquema de datos package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet String url="jdbc:odbc:datos"; // Se define la cadena de conexión (nombre del ODBC:datos) String usuario=""; String password=""; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); cn=DriverManager.getConnection(url,usuario,password); stmt=cn.createStatement(); // Se crea el comando rs=stmt.executeQuery("select * from Clientes"); while(rs.next()) // método avance al siguiente y devuelve true {
91
UNIVERSIDAD PRIVADA TELESUP
Visualiza el System.out.print(rs.getString("Codcli")+"\t"); contenido del System.out.print(rs.getString("Apecli")+"\t"); esquema de datos. System.out.print(rs.getString("Nomcli")+"\t"); Se puede utilizar. System.out.print(rs.getString("Dircli")+"\t"); System.out.println(""); } } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); }} }
7. Cerrar la conexión y el esquema de datos. Ejemplo completo: package comercial; import java.sql.*; public class GestionBD { public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet String url="jdbc:odbc:datos"; // Se define la cadena de conexión (nombre del ODBC:datos) String usuario=""; String password=""; try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); cn=DriverManager.getConnection(url,usuario,password); stmt=cn.createStatement(); // Se crea el comando rs=stmt.executeQuery("select * from Clientes");
while(rs.next()) // método avance al siguiente y devuelve true { System.out.print(rs.getString("Codcli")+"\t"); System.out.print(rs.getString("Apecli")+"\t"); System.out.print(rs.getString("Nomcli")+"\t"); System.out.print(rs.getString("Dircli")+"\t"); System.out.println(""); } Cierra la conexión y el rs.close(); esquema de datos. cn.close(); } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); }} }
92
UNIVERSIDAD PRIVADA TELESUP
EJECUTANDO SENTENCIAS SQL La Interfaz Statement Este tipo de interfaz nos permite definir un tipo de comando MDL de SQL (select, insert, update, delete) y ejecutarlo.
Los métodos más importantes de la interfaz Statement son: Método
Cancela el objeto Statement, abortando la sentencia SQL correspondiente. Cierra el objeto Statement liberando todos los recursos asociados de forma inmediata. Ejecuta la sentencia SQL que se pasa por parámetro Ejecuta una sentencia SQL que devuelve un conjunto de resultados, representando por el objeto ResultSet. Ejecuta la sentencia SQL que se pasa por parámetro y debe ser del tipo INSERT, UPDATE o DELETE Devuelve el objeto Connection a partir del que se ha creado el objeto Statement
Creando un objeto Statement Una vez que se ha establecido una conexión a una base de datos determinada, esta conexión se puede utilizar para enviar sentencias SQL a la base de datos. Un objeto Statement se crea con el método createStatement() de la clase Connection, como se puede observar en el fragmento de código que se muestra a continuación: Connection cn=DriverManager.getConnection(url,”pepe”,”xxx”); Statement st=cn.createStatement(); No olvidemos que si se trata de un comando Select que se desea ejecutar, invocaremos al método executeQuery. Ejemplo: Connection cn=DriverManager.getConnection(url,”pepe”,”xxx”); Statement st=cn.createStatement(); rs=st.executeQuery(“Select * from clientes”);
Si se trata de los comandos insert, update, delete y otros que modifican los datos de una tabla, utilizaremos el método executeUpdate. Ejemplo: Connection cn=DriverManager.getConnection(url,”pepe”,”xxx”); Statement st=cn.createStatement(); st.executeQuery(“insert into Clientes values (“„001‟,‟Garcia Díaz‟,‟Carla‟”);
93
UNIVERSIDAD PRIVADA TELESUP
MANIPULANDO RESULTADOS La Interfaz Resultset Es necesario usar un objeto que almacena todos los datos del resultado de una consulta, este objeto se llama ResultSet. JDBC devuelve los resultados en un objeto ResultSet, por eso necesitamos declarar un ejemplar de la clase ResultSet para contener los resultados. el siguiente código presenta el objeto ResultSet: rs y le asigna el resultado de una consulta anterior. ResultSet rs=st.executeQuery(“Select codcli,apecli,nomcli from Clientes”); El ResultSet es una estructura similar a la tabla de datos con la diferencia que nos es física, sino de tipo virtual, se creará en la memoria del Servidor y desde allí se tomarán los datos para mostrarlos posteriormente en el cliente.
MÉTODOS DEL RESULTSET Nombre del Método previous() next() first() last() isFirst() getString() getInt() getDate() getBoolean() getDouble() getLong()
Descripción Envía el puntero a la fila anterior del objeto ResultSet. (Devuelve true si encuentra la fila anterior) Envía el puntero a la fila siguiente del objeto ResultSet. (Devuelve true si encuentra la fila siguiente) Envía el puntero a la primera fila del objeto ResultSet. (Devuelve true si se encuentra primera fila) Envía el puntero a la última fila del objeto ResultSet. (Devuelve true si se encuentra última fila) Devuelve verdadero, si el puntero se encuentra en la primera fila Captura un dato de tipo String del esquema de datos Captura un dato de tipo int del esquema de datos Captura un dato de tipo Date del esquema de datos Captura un dato de tipo boolean del esquema de datos Captura un dato de tipo double del esquema de datos Captura un dato de tipo long del esquema de datos
EL MÉTODO NEXT El método next mueve al puntero o cursor a la siguiente fila y hace que esa fila (llamada fila actual) sea con la que podamos operar. Como el cursor inicialmente se posiciona justo encima de la primera fila de un objeto ResultSet, primero debemos llamar al método next para mover el cursor a la primera fila y convertirla en al fila actual. Sucesivas invocaciones del método next moverán el cursor de línea en línea hacia adelante. Existen otros métodos con los cuales podemos mover el puntero de la tabla o consultar sobre la posición actual del puntero (En la tabla anterior, aparece la lista de métodos que mueven el puntero de la tabla).
94
UNIVERSIDAD PRIVADA TELESUP
CONSEGUIR LOS DATOS DEL RESULTSET Método getXXX (XXX representa al tipo de dato, ejemplo: getDouble(), getString(), getLong(), etc) Los métodos getXXX del tipo apropiado se utilizan para recuperar el valor de cada columna. Por ejemplo: rs.getString(1); //Recupera el dato de la primera columna de la fila actual rs.getString(“CODCLI”); //Recupera el dato de la campo “CODCLI” de la fila actual
Nota: - La primera columna del ResultSet corresponde al número 1 - Podemos referirnos a un dato del ResultSet mediante su número o nombre de columna. Para conseguir otros tipos de datos contamos con los siguientes métodos: getByte
getBigDecimal
getShort
getBoolean
getInt
getString
getLong
getBytes
getFloat
getDate
getDouble
getTime
El ResultSet generado tiene la siguiente estructura: rs(1)
CodCli
rs(2)
ApeCli
rs(3)
rs(4)
NomCli
rs(5)
DirCli
DisCli
0001
Vargas Machuca Luís Alex
Av. Tupac Amaru 1254 Comas
0002
García López
Jorge Antonio Jr. Amazonas 258
Lima
0003
Sánchez Rojas
Randy
Av. José Pardo 365
Lince
0004
Salinas Montalvo Carla
Jr. Bolívar 2245
Breña
0006
Ore Palomino
Julio Cesar
Barranco
San Pedro
0007
Montalvo
Luís
San Martín de Porres
Av. Perú Cdra 28
0008
Villanueva
Freíd
Los Olivos
Av. Palmeras
0009
Palma López
Elian
San Juan
Av. Las Flores Parad
0010
Lozano Aguirre
Víctor
Comas
Tupac Amaru Km. 16
95
UNIVERSIDAD PRIVADA TELESUP
CONEXIÓN CON MÚLTIPLES ORÍGENES DE BASE DE DATOS Las conexiones JDBC, tal como estudiamos en la semana anterior, nos permiten conectarnos con diferentes orígenes de datos, lo único que tenemos que hacer es: Utilizar el driver provisto por el fabricante de la base de datos, la cual implementa la funcionalidad del JDBC para dicho gestor de Base de Datos. Lo único que variará en el código fuente es la forma de conexión, mientras que todo lo demás se mantendrá igual. Veamos algunos ejemplos:
a. Conexión con una base de datos mysql. Nombre de la base de datos: Comercial; nombre de la tabla: Clientes Previamente se requiere que el driver de mysql se inserte en el directorio de librerias externas de Java, situado en la siguiente ruta: C:\Archivos de programa\Java\jdk1.6.0\jre\lib\ext
Nota: El driver de mysql, se puede descargar de la página de mysql en Internet (link: Download). El archivo a descargar debe ser un archivo de extensión JAR. Para nuestro caso, este archivo se llama: mysql-connector-java-5.0.8-bin.jar (Este nombre puede cambiar de acuerdo al nombre de la versión)
96
UNIVERSIDAD PRIVADA TELESUP
Código fuente de la conexión JDBC con una base de Datos con MySQL package ConexionMysql; import java.sql.*; public class Conexion { public Conexion() { } public static void main(String[] args) { Statement stmt=null; // Declara el Objeto Statement Connection cn=null; // Declara el Objeto Connection ResultSet rs=null; // Declara el Objeto ResultSet
try { Class.forName(driver).newInstance(); cn=DriverManager.getConnection(urljdbc,usuario,password); stmt=cn.createStatement(); // Se crea el comando rs=stmt.executeQuery("select * from Clientes");
while(rs.next()) // método avance al siguiente y devuelve true { System.out.print(rs.getString("Codcli")+"\t"); System.out.print(rs.getString("Apecli")+"\t"); System.out.print(rs.getString("Nomcli")+"\t"); System.out.print(rs.getString("Dircli")+"\t"); System.out.println(""); } rs.close(); cn.close(); } catch(Exception e) { System.out.println("Error el proceso acceso a la base de datos"); System.out.println(e.getMessage()); } }}
97
UNIVERSIDAD PRIVADA TELESUP
Ejecución de la clase anterior:
Contenido de la tabla Clientes de Mysql desde PHPMyAdmin
98
UNIVERSIDAD PRIVADA TELESUP
Presentar el Contenido de una Tabla
TEMA 3
Competencia: Conocer el proceso de presentación adecuada de los contenidos de una tabla.
99
UNIVERSIDAD PRIVADA TELESUP
Tema 03: Presentar el Contenido de una Tabla
Para presentar el contenido de una tabla en una página JSP, se deben realizar los siguientes pasos: a.
Crear un proyecto Web y copiar hacia este proyecto las clases que nos permitirán realizar las operaciones con la base de datos. Crearemos dentro de la categoría Source Package, los paquetes Ds y Model. Dentro de la categoría WebPages insertaremos una carpeta View para la lógica de presentación.
100
UNIVERSIDAD PRIVADA TELESUP
b.
Importar las clases
c.
<%@page import="Ds.*"%> <%@page import="Model.*"%> <%@page import="java.sql.*"%> Instanciar la clase GestionBD y preparar el esquema de datos
<% GestionBD gbd=new GestionBD(); gbd.conectar(); String cad; cad="Select * from empleado order by chr_emplcodigo"; ResultSet rs=gbd.ejecutarConsulta(cad); %>
d.
Mostrar los datos del esquema de datos <% while(rs.next()) { %>
<%=rs.getString(1)%>
<%=rs.getString(2)%>
<%=rs.getString(3)%>
<%=rs.getString(4)%>
<%=rs.getString(5)%>
<%=rs.getString(6)%>
<%=rs.getString(7)%>
<%=rs.getString(8)%>
<% } %>
PAGINAR EL CONTENIDO DE UNA TABLA <%@ page contentType="text/html; charset=iso-8859-1" language="java" import="java.sql.*, java.util.*,java.lang.*,java.util.*, java.text.*,java.io.*" errorPage="" %>
101
UNIVERSIDAD PRIVADA TELESUP
Documento sin título <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> <script language="javascript" type="text/javascript"> //CUANDO LE DA CLIC EN SIGUIENTE SE MANDA A LLAMAR ESTA FUNCION function otraVez(){ document.form1.submit(); }
<% ResultSet rs1= null; Statement stmt1 = null; Connection con1 = null; String user=""; String pw=""; String url=""; String driverSQL=""; try{ funciones_jsp f = new funciones_jsp(); int total_reg=0; //-------------- CREACION DE ARREGLO DE LISTA ------------------------------------------ArrayList lista_fol = new ArrayList(); //- SI ESTA EL ARREGLO VACIO LO LLENA CON LA INFORMACION SOLICITADA -
//-------------- SE REALIZA LA CONSULTA DE SQL --------------------------------------------if (lista_fol.isEmpty()){ url = f.urlMttoSQL(); driverSQL = f.driverSQL(); user = f.usuarioSQL(); pw = f.claveSQL(); Class.forName(driverSQL); con1 = DriverManager.getConnection(url,user,pw); stmt1 = con1.createStatement(); rs1=stmt1.executeQuery("SELECT folio FROM t_servicios WHERE tipo='ACLARACION' ORDER BY fecha DESC"); //-------------- BORRO EL CONTENIDO DE LA LISTA -------------------------------------------lista_fol.clear(); //-------------- SE LLENA LA LISTA CON EL RESULTSET (rs1) ----------------------------//------- VARIABLE total_reg CONTIENE LA CANTIDAD TOTAL DE REGISTROS ----while (rs1.next()){ lista_fol.add(new Integer (rs1.getInt("folio"))); total_reg=total_reg+1; }//while }//if %>
MANTENIMIENTO DE DATOS A continuación presentaremos el código fuente de las páginas que nos permitirán realizar las operaciones de mantenimiento de datos.
Listado de Datos CLIENTES.JSP <%@page contentType="text/html"%> <%@page pageEncoding="UTF-8"%> <%@page import="java.sql.*"%> <%@page import="MiSistema.*"%> Mantenimiento de Clientes
Listado de Clientes
<%
106
UNIVERSIDAD PRIVADA TELESUP
GestionBD gd=new GestionBD(); ResultSet rs=null; gd.conectar(); rs=gd.ejecutarConsulta("Select * from Clientes"); int i=0; %>
Interface TEMA 4 Preparedstament y Callablest Competencia: Describir las propiedades y funcionalidades de la Interface Preparedstament y Callablestament.
111
UNIVERSIDAD PRIVADA TELESUP
Tema 04: La Interface Preparedstament y Callablest Algunas veces es más conveniente o eficiente utilizar objetos PreparedStatement para enviar sentencias SQL a la base de datos. Este tipo especial de sentencias se deriva de una clase más general, Statement, que ya conocemos.
Cuándo utilizar un Objeto PreparedStatement Si queremos ejecutar muchas veces un objeto Statement, reduciremos el tiempo de ejecución si utilizamos un objeto PreparedStatement, en su lugar. La característica principal de un objeto PreparedStatement es que, al contrario que un objeto Statement, se le entrega una sentencia SQL cuando se crea. La ventaja de esto es que en la mayoría de los casos, esta sentencia SQL se enviará al controlador de la base de datos inmediatamente, donde será compilado. Como resultado, el objeto PreparedStatement no sólo contiene una sentencia SQL, sino una sentencia SQL que ha sido precompilada. Esto significa que cuando se ejecuta la PreparedStatement, el controlador de base de datos puede ejecutarla sin tener que compilarla primero.
Aunque los objetos PreparedStatement se pueden utilizar con sentencias SQL sin parámetros, probablemente nosotros utilizaremos más frecuentemente sentencias con parámetros. La ventaja de utilizar sentencias SQL que utilizan parámetros es que podemos utilizar la misma sentencia y suministrar distintos valores cada vez que la ejecutemos. Veremos un ejemplo de esto en las páginas siguientes.
Crear un Objeto PreparedStatement Al igual que los objetos Statement, creamos un objeto
PreparedStatement
con
un
objeto
Connection. Utilizando nuestra conexión cn abierta en ejemplos anteriores, podríamos escribir lo siguiente
instrucción
para
crear
un
objeto
PreparedStatement que tome dos parámetros de entrada. PreparedStatement
ps=cn.prepareStatement("UPDATE
PRODUCTOS
SET
STOCKPRO = ? WHERE NOMPRO LIKE ?");
112
UNIVERSIDAD PRIVADA TELESUP
La variable ps contiene la sentencia SQL, "UPDATE PRODUCTOS SET STOCPRO = ? WHERE NOMPRO LIKE ?", que también ha sido, en la mayoría de los casos, enviada al controlador de la base de datos, y ha sido precompilado.
Suministrar Valores para los Parámetros de un PreparedStatement Necesitamos suministrar los valores que se utilizarán en los lugares donde están las marcas
de
interrogación,
si
hay
alguno,
antes
de
ejecutar
un
objeto
PreparedStatement. Podemos hacer esto llamando a uno de los métodos setXXX definidos en la clase PreparedStatement. Si el valor que queremos sustituir por una marca de interrogación es un int de Java, podemos llamar al método setInt. Si el valor que queremos sustituir es un String de Java, podemos llamar al método setString, etc. En general, hay un método setXXX para cada tipo Java. Utilizando el objeto ps del ejemplo anterior, la siguiente línea de código selecciona la primera marca de interrogación para un int de Java, con un valor de 75. ps.setInt(1, 75);
Cómo podríamos asumir a partir de este ejemplo, el primer argumento de un método setXXX indica la marca de interrogación que queremos seleccionar, y el segundo argumento el valor que queremos ponerle. El siguiente ejemplo selecciona la segunda marca de interrogación con el string "Arroz". ps.setString(2, "Arroz"); Después de que estos valores hayan sido asignados para sus dos parámetros, la sentencia SQL de ps será equivalente a la sentencia SQL que hay en el string cad del siguiente ejemplo. Por lo tanto, los dos fragmentos siguientes de código hacen lo mismo.
Código 1 String cad="UPDATE PRODUCTOS SET STOCKPRO=75 WHERE NOMPRO LIKE 'Arroz'"; stmt.executeUpdate(cad);
Código 2 PreparedStatement ps=cn.prepareStatement("UPDATE STOCKPRO=? WHERE NOMPRO LIKE ?"); ps.setInt(1, 75); ps.setString(2, "Arroz"); ps.executeUpdate().
PRODUCTOS
SET
113
UNIVERSIDAD PRIVADA TELESUP
Mirando esto ejemplos podríamos preguntarnos por qué utilizar un objeto PreparedStatement con parámetros en vez de una simple sentencia, ya que la sentencia simple implica menos pasos. Si actualizáramos la columna STOCKPRO sólo una o dos veces, no sería necesario utilizar una sentencia SQL con parámetros. Si por otro lado, tuviéramos que actualizarla frecuentemente, podría ser más fácil utilizar un objeto PreparedStatement, especialmente en situaciones cuando la utilizamos con un bucle while para seleccionar un parámetro a una sucesión de valores. Veremos este ejemplo más adelante en esta sección. Una vez que a un parámetro se ha asignado un valor, el valor permanece hasta que lo resetee otro valor o se llame al método clearParameters. Utilizando el objeto PreparedStatement: ps, el siguiente fragmento de código reutiliza una sentencia prepared después de resetar el valor de uno de sus parámetros, dejando el otro igual.
Utilizar una Bucle para asignar Valores Normalmente se codifica más sencillo utilizando un bucle for o while para asignar valores de los parámetros de entrada. El siguiente fragmento de código demuestra la utilización
de
un
bucle
for
para
asignar
los
parámetros
en
un
objeto
PreparedStatement: ps. El array stocks contiene las cantidades del stock de los productos. Estas cantidades corresponden con los nombres de los productos listados en el array productos, por eso la primera cantidad de stocks (175) se aplica al primer nombre de productos ("Arroz"), la segunda cantidad de stocks (150) se aplica al segundo nombre de productos ("Azúcar"), etc. Este fragmento de código demuestra la actualización de la columna STOCKPRO para todos los Nombre de Productos de la tabla PRODUCTOS.
PreparedStatement ps; String cad="update PRODUCTOS set STOCPRO=? where NOMPRO like ?"; ps=con.prepareStatement(cad); int[] stocks={175, 150, 60, 155, 90}; String[] productos={"Arroz","Azúcar","Aceite","Mantequilla","Leche"}; int len=stocks.length; for(int i=0;i
114
UNIVERSIDAD PRIVADA TELESUP
Cuando el propietario quiere actualizar los nuevos stocks de la semana siguiente, puede utilizar el mismo código como una plantilla. Todo lo que tiene que hacer es introducir las nuevas cantidades en el orden apropiado en el array stocks. Los nombres de los productos permanecen constantes, por eso no necesitan cambiarse. (En una aplicación real, los valores probablemente serán introducidos por el usuario en vez de hacerlos a través de un array).
Valores de retorno del método executeUpdate Siempre que executeQuery devuelve un objeto ResultSet que contiene los resultados de una petición al controlador de la base datos, el valor devuelto por executeUpdate es un int que indica cuántas líneas de la tabla fueron actualizadas. Por ejemplo, el siguiente código muestra el valor de retorno de executeUpdate asignado a la variable n. ps.setInt(1, 50); ps.setString(2, "Arroz"); int n=ps.executeUpdate(); //n recepciona la cantidad de filas que fueron actualizadas
La tabla PRODUCTOS se ha actualizado poniendo el valor 50 en la columna STOCPRO de la fila correspondiente a Arroz. La actualización afecta sólo a una línea de la tabla, por eso n es igual a 1. Cuando el método executeUpdate es utilizado para ejecutar una sentencia DDL, como la creación de una tabla, devuelve el int: 0. Consecuentemente, en el siguiente fragmento de código, que ejecuta la sentencia DDL utilizada para crear la tabla PRODUCTOS, n tendrá el valor 0. String comando=”Create Tables categorías(codcat char(3), nomcat varchar(25)); int n = executeUpdate(comando); // n = 0 Observa que cuando el valor devuelto por executeUpdate sea 0, puede significar dos cosas: (1) la sentencia ejecutada no ha actualizado ninguna fila, o (2) la sentencia ejecutada fue una sentencia DDL.
LA INTERFACE CALLABLESTATEMENT Ejecución de Procedimientos Almacenados Antes de explicar detalladamente el uso de la interfaz CallableStatment, analicemos brevemente: ¿Qué son los procedimientos almacenados?
115
UNIVERSIDAD PRIVADA TELESUP
¿QUÉ ES UN PROCEDIMIENTO ALMACENADO? Un procedimiento almacenado (stored procedure en inglés) es un programa (o procedimiento) el cual es almacenado físicamente en una base de datos. Su implementación varía de un manejador de bases de datos a otro. Un procedimiento almacenado es un elemento de base de datos reutilizable almacenado que realiza alguna operación en la base de datos. Un procedimiento almacenado contiene código SQL que puede, entre otras cosas, insertar, actualizar o eliminar registros. Los procedimientos almacenados también pueden alterar la estructura de la base de datos. Por ejemplo, puede utilizar un procedimiento almacenado para añadir una columna de tabla o incluir borrar una tabla. Un procedimiento almacenado también puede llamar a otro procedimiento almacenado, así como aceptar entradas y devolver múltiples valores al procedimiento llamado en forma de parámetros de salida. Habitualmente los procedimientos almacenados se escriben en un lenguaje de bases de datos propietario.
VENTAJAS DEL TRABAJO CON PROCEDIMIENTOS ALMACENADOS Seguridad: Cuando llamamos a un procedimiento almacenado, este deberá
realizar todas las comprobaciones pertinentes de seguridad y seleccionará la información lo más precisamente posible, para enviar de vuelta la información justa y necesaria y que por la red corra el mínimo de información, consiguiendo así un aumento del rendimiento de la red considerable. Rendimiento: el SGBD, en este caso MySQL, es capaz de trabajar más rápido con
los datos que cualquier lenguaje del lado del servidor, y llevará a cabo las tareas con más eficiencia. Solo realizamos una conexión al servidor y este ya es capaz de realizar todas las comprobaciones sin tener que volver a establecer una conexión. Esto es muy importante, una vez leí que cada conexión con la BD puede tardar hasta medios segundo, imagínate en un ambiente de producción con muchas visitas como puede perjudicar esto a nuestra aplicación…Otra ventaja es la posibilidad de separar la carga del servidor, ya que si disponemos de un servidor de base de datos externo estaremos descargando al servidor web de la carga de procesamiento de los datos. Reutilización: el procedimiento almacenado podrá ser invocado desde cualquier
parte del programa, y no tendremos que volver a armar la consulta a la BD cada qué vez que queramos obtener unos datos.
116
UNIVERSIDAD PRIVADA TELESUP
CALLABLESTATEMENT Un objeto CallableStatement es una interface JDBC utilizado para llamar o ejecutar procedimientos almacenados de la base de datos desde una aplicación Java. Antes de usar CallableStatement debemos saber si nuestro Gestor de Base de Datos soporta y usa procedimientos almacenados, para este propósito el método supportsStoredProcedures devolverá true si la DBMS soporta llamadas a procedimientos almacenados y el método getProcedures devolverá una descripción de los procedimientos almacenados disponibles. CALLABLESTATEMENT hereda los métodos de Statement, los cuales tratan sentencias SQL en general, y también hereda los métodos de PreparedStatement, que tratan los parámetros IN. Todos los métodos definidos para CallableStatement tratan los parámetros OUT o los aspectos de salida de los parámetros INOUT: registro de los tipos JDBC (tipos genéricos SQL) de los parámetros OUT, recuperación de valores desde ellos o chequear si el valor devuelto es un JDBC NULL.
Crear objetos CallableStatement Los objetos CallableStatement se crean con el método prepareCall de Connection. El siguiente ejemplo crea una instancia de CallableStatement que contiene una llamada al procedimiento almacenado getTestData, con dos argumentos y no devuelve resultados. CallableStatement cs = cn.prepareCall("{call getTestData(?, ?)}"); Los los encajes „?‟ son parámetros IN, OUT ó INOUT dependiendo del procedimiento getTestData.
Parámetros IN y OUT El paso de valor para cualquier parámetro IN de un objeto CallableStatement se realiza mediante los métodos setXXX heredados de PreparedStatement. El tipo de el valor a pasar se determina por el método setXXX a usar (setFloat para pasar un valor float, setString para pasar un valor String y así por estilo). Si el procedimiento almacenado devuelve parámetros OUT, el tipo JDBC de cada parámetro OUT debe ser registrado antes de que el objeto CallableStatement sea ejecutado. El registro del tipo JDBC se realiza mediante el método registerOutParameters. Después que la sentencia ha sido ejecutada, los métodos getXXX de CallableStatement recuperan los valores de los parámetros.
117
UNIVERSIDAD PRIVADA TELESUP
Para ilustrar esto, el siguiente ejemplo registra los parámetros OUT, ejecuta el procedimiento almacenado llamado por cs y recupera los valores devueltos en los parámetros OUT. El método getInt recupera un int del primer parámetro, y getDouble recupera un doublé del segundo parámetro OUT: CallableStatement cs = con.prepareCall("{call getTestData(?, ?)}"); cs.registerOutParameter(1, java.sql.Types.TINYINT); cs.registerOutParameter(2, java.sql.Types.DECIMAL); cs.executeQuery(); //Ejecuta el procedimiento almacenado byte x = cs.getint(1); //Recupera el valor del 1er parámetro de salida double n = cs.getDouble(2); //Recupera el 2do parámetro de salida
Parámetros INOUT Son parámetros que suministran entradas así como aceptan salidas. Estos requieren llamar a los métodos apropiados setXXX (heredados de PreparedStatement) además de llamar al método registerOutParameter. Los métodos setXXX fijan los valores como parámetros de entrada y registerOutParameter registra sus tipos JDBC como parámetros de salida. El método setXXX suministra un valor Java que el driver convierte en un valor JDBC antes de enviarlo a la base de datos. El tipo JDBC del valor IN y el tipo JDBC para suministrado al método registerOutParameter debe ser el mismo. Luego, para recuperar el valor de salida, se usa el método apropiado getXXX. Por ejemplo, un parámetro cuyo tipo Java es byte debería usar el método setByte para asignar el valor de entrada, debería suplir un TINYINT como tipo JDBC para registerOutParameter, y debería usar getByte para recuperar el valor de salida El siguiente ejemplo asume que existe un procedimiento almacenado reviseTotal con un único parámetro INOUT. El método setByte fija el valor del parámetro a 25 que es el que el driver enviará a la base de datos como un JDBC TINYINT. Después registerOutParameter registrará el parámetro como un JDBC TINYINT. Luego que el procedimiento sea ejecutado se devolverá un nuevo JDBC TINYINT y el método getByte lo recuperará como un nuevo valor byte Java.
Recuperar parámetros OUT después de resultados Dadas las limitaciones impuestas por algunas DBMS, se recomienda en aras de la máxima portabilidad, que todos los resultados generados por la ejecución de un objeto CallableStatement deberían recuperarse antes que los parámetros OUT usando los métodos CallableStatement.getXXX. Si un objeto CallableStatement devuelve múltiples objetos ResultSet (mediante una llamada al método execute), todos los resultados deben recuperarse antes que los parámetros OUT. En este caso, debe asegurarse de que todos los resultados han sido accedidos, los métodos de Statement getResultSet, getUpdateCount y getMoreResults necesitan ser llamados hasta que no haya más resultados. Después de hecho esto, los valores de los parámetros OUT pueden ser recuperados mediante los métodos CallableStatement.getXXX.
Recuperar valores NULL en parámetros OUT El valor devuelto en un parámetro OUT puede ser JDBC NULL. Cuando esto ocurre, le valor JDBC NULL se convertirá de forma que el valor devuelto por el método getXXX sea null, 0 o false dependiendo del tipo del método getXXX usado. Como con los objetos ResultSet, la única manera de saber si un valor de 0 o false fue originalmente NULL JDBC es testear el método wasNull, que devuelve true si el último valor leído por un método getXXX fue JDBC NULL y false en caso contrario.
Métodos de CallableStatement Registro de los parámetros: registerOutParameter() public abstract void registerOutParameter( int indiceParametro, int tipoSQL [, int decimales] ) throws SQLException
Debe llamarse antes de ejecutar la orden precompilada para registrar los tipos SQL de cada uno de los parámetros de salida. Parámetros nulos: wasNull() public abstract boolean wasNull() throws SQLException Devuelve true si el valor previamente leído con un método getXXX() era realmente nulo.
Obtención de valores: getXXX() public abstract tipoJava getXXX(int indiceParametro) throws SQLException Obtienen el valor SQL contenido en el parámetro como un tipoJava, o un null si se trataba de un valor NULL de SQL.
Boolean Byte Short Int Long Float Doublé BigDecimal byte[]
GetDate GetTime getTimestamp
Date Time Timestamp
CHAR, VARCHAR o Null LONGVARCHAR BIT false TINYINT cero SMALLINT cero INTEGER cero BIGINT cero FLOAT cero DOUBLE cero NUMERIC Null BINARY o Null VARBINARY DATE Null TIME Null TIMESTAMP Null
Caso Práctico Realizar una aplicación Java que utilizando procedimientos almacenados consulte que cuentas corresponde a una sucursal de un banco,
Código de Búsqueda Este código crea un CallableStatement para ejecutar el procedimiento almacenado usp_filtra_ctas_sucur que usa un parámetro de entrada, con el método setString ingresamos el valor del primer parámetro de entrada y luego ejecutamos el procedimiento almacenado con el método executeQuery, porque se trata de un comando Select
USP_FILTRA_CTAS_SUCUR DELIMITER $$ DROP PROCEDURE IF EXISTS `Eurekabank`.`usp_filtra_ctas_sucur`$$ CREATE PROCEDURE `usp_filtra_ctas_sucur`(IN codsucu char(3)) BEGIN select * from cuenta where chr_sucucodigo=codsucu; END$$ DELIMITER;
EJECUCIÓN DE PROCEDIMIENTOS ALMACENADOS Un procedimiento almacenado luego de ser creado en Mysql, puede ser ejecutado de la siguiente forma: call usp_filtra_ctas_sucur(„001‟); Desde Java, para ejecutar un procedimiento almacenado debemos: CallableStatement cs=null; cs=cn.prepareCall("{call usp_filtra_ctas_sucur(?)}"); cs.setString(1,”002”); ResultSet rs=cs.executeQuery();
121
UNIVERSIDAD PRIVADA TELESUP
Lecturas Recomendadas
INTRODUCCIÓN AL JDBC http://eisc.univalle.edu.co/materias/BD/IntroduccionAlJDBC.pdf
1. Modifique el programa de mantenimiento de datos y adáptelo para que trabaje con Procedimientos almacenados. Envíalo a través de "Procedimientos Almacenados".
122
UNIVERSIDAD PRIVADA TELESUP
Autoevaluación
1) Los Driver, también llamados ___________, son un conjunto de clases que implementan las clases e interfaces del API JDBC: a. Manejadores. b. Sybase. c. Hacer los algoritmos de nuestro proyecto. d. Propiedades. e. Consolas. 2) ¿Cuántos tipos de manejadores JDBC hay? a. Dos. b. Tres. c. Cuatro. d. Ocho. e. Siete. 3) Registrar un _____________ no es más que cargar en memoria una clase que implementa el interfaz Driver. a. Statement. b. Callable. c. Manejador. d. Protocolo. e. Subprotocolo.
4) ¿Cual es una función del JDBC? a. Detener la función de la base de datos. b. Establecer una conexión con dos tablas. c. Decodificar los datos. d. Procesar los resultados de la consulta. e. Funciona como un compilador de un lenguaje de programación. 5) Toda URL de JDBC consta siempre de _____ partes. a. Cuatro b. Seis c. Ocho d. .Diez e. Tres
123
UNIVERSIDAD PRIVADA TELESUP
6) Todos los métodos que encontramos en esta clase son estáticos: a. Clase DriverManager. b. Clase Connection. c. Clase Statement. d. Clase PreparedStatement. e. Clase ResultSet.
7) El Procedimiento almacenado es conocido también como: a. DriverManager. b. RequestParameter. c. Callablestament. d. PreparedStatement. e. Stored procedure.
8) Es un elemento de base de datos reutilizable almacenado que realiza alguna operación en la base de datos: a. Sentencia. b. Constante. c. Variable. d. Procedimiento almacenado. e. Clase heredada.
9) Es una interface JDBC utilizado para llamar o ejecutar
procedimientos
almacenados de la base de datos desde una aplicación Java. a. getProcedures. b. Statement. c. PreparedStatement. d. ResultSet. e. supportsStoredProcedures.
10) Los objetos Statement se cerrarán automáticamente por el: a. ResultSet. b. garbage collector. c. Connection. d. DriverManager.getConnection. e. boolean execute.
124
UNIVERSIDAD PRIVADA TELESUP
Resumen
UNIDAD DE APRENDIZAJE ii:
Con el API JDBC, no es necesario escribir un programa que acceda a una base de datos Sybase, otro para acceder a Oracle y otro para acceder a Informix. Un único programa escrito usando el API JDBC y el programa será capaz de enviar sentencias SQL a la base de datos apropiada. Y, con una aplicación escrita en el lenguaje de programación Java, tampoco es necesario escribir diferentes aplicaciones para ejecutar en diferentes plataformas.
Lo que hace la clase DriverManager para intentar establecer conexión con la base de datos es invocar al método connect de la interface Driver, interface que como veremos deben implementar todos los manejadores. Realiza esta operación con todos los manejadores que tiene registrados, si el manejador devuelve null significa que no se ha podido conectar con la base de datos, y el gestor intenta de nuevo conectarse con otro manejador.
La característica principal de un objeto PreparedStatement es que, al contrario que un objeto Statement, se le entrega una sentencia SQL cuando se crea. La ventaja de esto es que en la mayoría de los casos, esta sentencia SQL se enviará al controlador de la base de datos inmediatamente, donde será compilado.
Un procedimiento almacenado es un elemento de base de datos reutilizable almacenado que realiza alguna operación en la base de datos. Un procedimiento almacenado contiene código SQL que puede, entre otras cosas, insertar, actualizar o eliminar registros. Los procedimientos almacenados también pueden alterar la estructura de la base de datos.
125
UNIVERSIDAD PRIVADA TELESUP
126
UNIVERSIDAD PRIVADA TELESUP
Introducción
a) Presentación y contextualización El modelo–vista–controlador (MVC) es un patrón de arquitectura de software que separa los datos y la lógica de negocio de una aplicación de la interfaz de usuario y el módulo encargado de gestionar los eventos y las comunicaciones.
b) Competencia Conoce las propiedades y funcionalidades del patrón de diseño MVC (Model – View - Controller).
c) Capacidades 1. Conoce las características y funciones de Servlet. 2. Reconoce los principales pasos para crear un servlet. 3. Analiza el modelo vista controlador (Model – View - Controller). 4. Utiliza objetivamente la consulta de datos (Model – View - Controller).
d) Actitudes Promueve el uso adecuado de los patrones del (Model – View - Controller). Cumple cada uno de los pasos para crear un Servlet.
e) Presentación de Ideas básicas y contenido esenciales de la Unidad: La Unidad de Aprendizaje 03: Patrón de Diseño MVC (Model – View - Controller), comprende el desarrollo de los siguientes temas:
TEMA 01: Servlet TEMA 02: Pasos para Crear un Servlet TEMA 03: Modelo Vista Controlador (MVC). TEMA 04: Consulta de Datos – MVC.
127
UNIVERSIDAD PRIVADA TELESUP
Servlet
TEMA 1
Competencia: Conocer las características y funciones de Servlet.
128
UNIVERSIDAD PRIVADA TELESUP
Desarrollo de los Temas
Tema 01: Servlet Los servlets son objetos que corren dentro del contexto de un contenedor de servlets (ej: Tomcat) y extienden su funcionalidad. También podrían correr dentro de un servidor de aplicaciones (ej: OC4J Oracle) que además de contenedor
para
servlet
tendrá
contenedor para objetos más avanzados como son los EJB (Tomcat sólo es un contenedor de servlets).
La palabra servlet deriva de otra anterior, applet, que se refería a pequeños programas escritos en Java que se ejecutan en el contexto de un navegador web. Por contraposición, un servlet es un programa que se ejecuta en un servidor. El uso más común de los servlets es generar páginas web de forma dinámica a partir de los parámetros de la petición que envíe el navegador web. Los servlets forman parte de JEE (Java Enterprise Edition), que es una ampliación de JSE (Java Standard Edition).
Un servlet es un objeto Java que implementa la interfaz javax.servlet.Servlet o hereda alguna de las clases más convenientes para un protocolo específico
(ej:
javax.servlet.HttpServlet).
Al
implementar esta interfaz el servlet es capaz de interpretar los objetos de tipo HttpServletRequest y HttpServletResponse quienes contienen la información de la página que invocó al servlet. Los Servlets son la respuesta de la tecnología Java a la programación CGI.
129
UNIVERSIDAD PRIVADA TELESUP
Son programas que se ejecutan en un servidor Web y construyen páginas Web. Construir páginas Web al vuelo es útil (y comúnmente usado) por un número de razones:
La página Web está basada en datos enviados por el usuario. Por ejemplo, las páginas de resultados de los motores de búsqueda se generan de esta forma, y los programas que procesan pedidos desde sites de comercio electrónico también.
Los datos cambian frecuentemente. Por ejemplo, un informe sobre el tiempo o páginas de cabeceras de noticias podrían construir la página dinámicamente, quizás devolviendo una página previamente construida y luego actualizándola.
Las páginas Web que usan información desde bases de datos corporativas u otras fuentes. Por ejemplo, usaríamos esto para hacer una página Web en una tienda on-line que liste los precios actuales y el número de artículos en stock.
130
UNIVERSIDAD PRIVADA TELESUP
Modelo response/request Aquí tenemos un servlet básico que maneja peticiones GET. Las peticiones GET, para aquellos que no estemos familiarizados con HTTP, son peticiones hechas por el navegador cuando el usuario escribe una URL en la línea de direcciones, sigue un enlace desde una página Web, o rellena un formulario que no especifica un METHOD. Los Servlets también pueden manejar peticiones POST muy fácilmente, que son generadas cuando alguien crea un formulario HTML que especifica METHOD="POST".
import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class SomeServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// Use "request" to read incoming HTTP headers (e.g. cookies) // and HTML form data (e.g. data the user entered and submitted) // Use "response" to specify the HTTP response line and headers // (e.g. specifying the content type, setting cookies). PrintWriter out = response.getWriter(); // Use "out" to send content to browser } }
131
UNIVERSIDAD PRIVADA TELESUP
Para
ser un servlet, esta
debe
extender de
HttpServlet y sobreescribir doGet o doPost (o ambos), dependiendo de si los datos están siendo enviados mediante GET o POST. Estos métodos toman dos argumentos: un HttpServletRequest y un HttpServletResponse.
El HttpServletRequest tiene métodos que nos permiten encontrar información entrante como datos de un FORM, cabeceras de petición HTTP, etc. El HttpServletResponse tiene métodos que nos permiten especificar líneas de respuesta HTTP (200, 404, etc.), cabeceras de respuesta (ContentType, Set-Cookie, etc.), y, todavía más importante, nos permiten obtener un PrintWriter usado para envíar la salida de vuelta al cliente. Para servlets sencillos, la mayoría del esfuerzo se gasta en sentencias println que generan la página deseada.
132
UNIVERSIDAD PRIVADA TELESUP
Observamos que doGet y doPost lanzan dos excepciones, por eso es necesario incluirlas en la declaración. También observamos que tenemos que importar las clases de los paquetes java.io (para PrintWriter, etc.), javax.servlet (para HttpServlet, etc.), y javax.servlet.http (para HttpServletRequest y HttpServletResponse). Finalmente, observamos que doGet y doPost son llamados por el método service, y algunas veces queremos sobreescribir directamente el método service, por ejemplo, para un servlet que maneje tanto peticiones GET como POST.
Ciclo de vida de un servlet 1. Un Servlet es una clase extendida de la superclase HttpServlet 2. Recepciona datos provenientes del usuario con los métodos doPost() y doGet() 3. Los datos de entrada son procesados con el método processRequest() 4. Se utiliza el objeto out para direccionar las respuestas hacia el navegador del cliente.
133
UNIVERSIDAD PRIVADA TELESUP
Pasos para Crear un Servlet
TEMA 2
Competencia: Reconocer los principales pasos para crear un servlet.
134
UNIVERSIDAD PRIVADA TELESUP
Tema 02: Pasos para Crear un Servlet PRERREQUISITO: Debemos tener instalado cualquiera de los siguientes servidores
webs:
Apache
Tomcat,
GlassFish
o
GlassFish Prelude (Para verificar si dichos servidores se encuentran instalados, podemos acudir en Netbeans a: Menu Tools / Servers).
Nota: Es importante que ninguno de estos servidores use un puerto que ya está siendo utilizado, porque esto generaría conflicto y por tanto imposibilitaría que el proyecto web se ejecute. 1. Crear un proyecto Web, acuda a Menu File / New Project 2. Seleccione Java Web / Web Application
3. Botón Siguiente 4. Ingrese el nombre del proyecto web / Botón Next
135
UNIVERSIDAD PRIVADA TELESUP
5. Escoger el servidor web con el que desea trabajar. 6. Nota: Si no encuentra servidores disponibles, debe volver a instalar Netbeans de modo personalizado y agregar un servidor
7. Haga click en el botón Next
136
UNIVERSIDAD PRIVADA TELESUP
8. Haga click en el botón Finish 9. Antes de crear un servlet, debemos crear un paquete. Click derecho sobre la categoría Web Pages / Escoger New / Java Package
10. Ingresar el nombre del paquete, para nuestro caso será: Servlets / Luego Finish
11. Crear el servlet dentro del paquete, click derecho sobre el paquete y escoger New / Servlet
137
UNIVERSIDAD PRIVADA TELESUP
12. Ingresar el nombre del Servlet: Demo / Botón Next
13. Luego haga click en el botón Finish
138
UNIVERSIDAD PRIVADA TELESUP
14. A continuación aparecerá el código fuente de la clase Servlet. El método processRequest es el método principal de la clase Servlet que responde a la peticiones del usuario (request) y escribe (response) resultados finales en el navegador del cliente. Descomentamos las líneas que contienen código HTML y podemos agregar algunas líneas nuestras.
A continuación agregamos algunas líneas nuestras:
139
UNIVERSIDAD PRIVADA TELESUP
16. Para ejecutar el Servlet, presionamos la teclas Shif F6 / Confirmemos la ventana siguiente, haciendo click en el botón OK
La ejecución de nuestro Servlet, es la siguiente:
Importante: En Netbeans debemos indicar el nombre del navegador que utilizaremos para visualizar la ejecución de nuestros Servlets, acudir a Menu Tools / Options / Categoría General / Web Browser: Internet Explorer.
140
UNIVERSIDAD PRIVADA TELESUP
Manejar datos de formularios
En cambio, una de las mejores características de los servlets Java es que todos estos análisis de formularios son manejados automáticamente. Simplemente llamamos al método getParameter de HttpServletRequest, y suministramos el nombre del parámetro como un argumento. Observa que los nombres de parámetros son sensibles a la mayúsculas. Hacemos esto exactamente igual que cuando los datos son enviados mediante GET o como si los enviáramos mediante POST.
El valor de retorno es un String correspondiente al valor de la primera ocurrencia del parámetro. Se devuelve un String vacío si el parámetro existe pero no tiene valor, y se devuelve null si no existe dicho parámetro. Si el parámetro pudiera tener más de un valor, como en el ejemplo anterior, deberíamos llamar a getParameterValues en vez de a getParameter. Este devuelve un array de strings. Finalmente, aunque en aplicaciones reales nuestros servlets probablemente tengan un conjunto específico de nombres de parámetros por los que buscar. Usamos getParameterNames para esto, que devuelve una Enumeración, cada entrada puede ser forzada a String y usada en una llamada a getParameter.
141
UNIVERSIDAD PRIVADA TELESUP
Ejemplo: Un Servlet que lee tres parámetros enviados por un formulario Aquí hay un sencillo ejemplo que lee tres parámetros llamados param1, param2, y param3, listando sus valores
en
una
lista
marcada.
Observamos que, aunque tenemos que
especificar
selecciones
de
respuesta (content type, status line, otras cabeceras HTTP) antes de empezar a generar el contenido, no es necesario que leamos los parámetros de petición en un orden particular.
También observamos que podemos crear fácilmente servlets que puedan manejar datos GET y POST, simplemente haciendo que su método doPost llame a doGet o sobreescribiendo service (que llama a doGet, doPost, doHead, etc.). Esta es una buena práctica estándard, ya que requiere muy poco trabajo extra y permite flexibilidad en el lado del cliente. Si hemos usado la aproximación CGI tradicional cuando leemos los datos POST mediante la entrada estándard.
Deberíamos observar que hay una forma similar con los Servlets llamando primero a getReader o getInputStream sobre HttpServletRequest. Esto es una mala idea para parámetros normales, pero podría usarse para ficheros descargados o datos POST que están siendo enviados por clientes personales en vez de formularios HTML. Observa, sin embargo, que si leemos los datos POST de esta manera, podrían no ser encontrados por getParameter.
142
UNIVERSIDAD PRIVADA TELESUP
package hall; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import java.util.*; public class ThreeParams extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); String title = "Reading Three Request Parameters"; out.println(ServletUtilities.headWithTitle(title) + "\n" + "
\n" + ""); } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } } Salida de los 3 parámetros
143
UNIVERSIDAD PRIVADA TELESUP
Ejemplo: Listar todos los Datos del Formulario Aquí hay un ejemplo que busca todos los nombres de parámetros que fueron enviados y los pone en una tabla. Ilumina los parámetros que tienen valor cero así como aquellos que tienen múltiples valores. Primero busca todos los nombres de parámetros mediante el método getParameterNames de HttpServletRequest. Esto devuelve una Enumeration. Luego, pasa por la Enumeration de la forma estándard, usando hasMoreElements para determinar cuándo parar y usando nextElement para obtener cada entrada.
Como nextElement devuelve un Object, fuerza el resultado a String y los pasa a getParameterValues, obteniendo un array de Strings. Si este array sólo tiene una entrada y sólo contiene un string vacío, el parámetro no tiene valores, y el servlet genera una entrada "No Value" en itálica. Si el array tiene más de una entrada, el parámetro tiene múltiples valores, y se muestran en una lista bulleteada. De otra forma, el único valor principal se sítua en la tabla.