Como hacer paginación con JSP

Transcripción

1 Como hacer paginación con JSP Documento propiedad del portal Autor: Miguel Angel García, Pág. 1 de 35

2 Ref: REX PAG. HOJA DE INFORMACIÓN GENERAL CONTROL DOCUMENTAL PROYECTO: ENTIDAD DE DESTINO: TITULO: CODIGO DE REFERENCIA: Rexerve.com Cómo hacer paginación con páginas JSP. REX PAG. VERSION: 2.0 FECHA EDICION: AUTOR: Miguel Angel García RESUMEN: El documento explica cómo hacer paginación de registros, con páginas JSP. DERECHOS DE USO: La presente documentación es propiedad del portal. No tiene carácter de confidencial y podrá ser objeto de reproducción total o parcial, tratamiento informático o transmisión de cualquier forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, registro o cualquiera otro. Asimismo se advierte que los nombres de los propietarios deberán quedar intactos, informando siempre al destinatario final, de dónde se ha obtenido este material. El incumplimiento de las limitaciones señaladas por cualquier persona que tenga acceso a la documentación será perseguido conforme a ley vigente. Pág. 2 de 35

3 Paginación Muchos de vosotros me pedisteis en su día como hacer paginación de registros con Jsp. Quizá en el tutorial de Introducción a Jsp no quedó demasiado claro en su día. Pues bien a partir de ahora, vamos a comenzar un tutorial que os permitirá crear páginas jsp, gracias a un Bean, que muestren registros de una consulta paginados de n en n registros por página. Qué es la paginación de registros? Lo primero de todo es saber de qué estamos hablando, la paginación de registros (a partir de ahora paginación) es la propiedad de mostrar los resultados de una consulta, sea cual sea, el número de registros que devuelva dicha consulta, acotados en número de registros por página. Es decir y en resumen, mostrar por ejemplo, los registros de una consulta de 10 en 10 ó de 20 en 20, o de lo que haga falta. Esta imagen muestra como quedará la página cuando acabemos el tutorial: Esta figura muestra los registros de una consulta o tabla mediante páginas, lo que ocurre es que quizá el ejemplo que he puesto, no es demasiado identificativo porque da la casualidad de que solo tiene una página, pero tranquilos lo que haremos podrá tener tantas páginas como queramos. Y además se podrá parametrizar el número de registros que se desea mostrar por página y muchas otras cosas, como hacer ordenación por un campo que seleccione el usuario o hacer clic en un campo y que se redireccione a otra página incluso pasándole parámetros de la misma consulta. Pág. 3 de 35

4 Estructura del desarrollo y arquitectura. El desarrollo consistirá en crear primeramente un Bean llamado BeanPaginacion.java que tendrá todos métodos y propiedades necesarios para ser utilizado desde una página jsp. Este Bean, será standard y funcionará con cualquier consulta que le pasemos y con cualquier número de campos y registros. Es decir desarrollaremos un componente totalmente autónomo que permita realizar paginación de registros de forma básica y linealmente, de cualquier consulta sencilla. Imposible?. No. Yo lo hice, me costó bastante, pero al final es el Bean que más uso hoy en día y siempre lo llevo conmigo en todos los proyectos, y más pensando que tengo miles de registros en las tablas de mi Oracle y que sacar consultas con muchos datos supondría un trauma muy grande tanto para el navegador como para el usuario que podría esperar indefinidamente a que se ejecutara la consulta. Por supuesto la base de datos que usaremos será Oracle (8.1.7) que es la que tengo montada, sobre un Windows Server en diferente servidor que dónde se ejecutan las páginas. El servidor web es Apache lógicamente, y el servidor de Servlets montado en mi Linux RedHat 7.1, es Jakarta-Tomcat.Con esto tenemos de sobra para empezar a trabajar. La verdad es que no lo he probado con ninguna otra base de datos, pero no creo que encontréis problemas a lo hora de implementar el desarrollo para distintos motores de gestión de datos. A quién va dirigido? A todo el mundo, principiantes, intermedios o avanzados que quieran profundizar. Pero antes de nada tendréis que tener en cuenta que deberéis saber algo sobre: Beans Oracle SQL Arrays de Java Session Formularios Si conocéis algo de todo esto, no os costará nada comprender qué hace y cómo funciona en Bean Paginacion En cuanto al desarrollo necesitareis unas cuantas imágenes, para que el resultado del BeanPaginacion surta efecto, estas imágenes ya os las pasaré cuando nos hagan falta no os preocupeis, aunque cada uno puede poner las imágenes que le de la gana. Pág. 4 de 35

5 Estas imágenes, son por ejemplo, las que saldrán para pulsar en siguiente página, página anterior, etc.o los bordes del marco de la tabla de resultados.estas imágenes deberán ir ubicados en un directorio llamado images, pero ya os digo, lo veremos más adelante. Pág. 5 de 35

6 Funcionalidad Los ejemplos que vamos a crear consistirán en una o múltiples consultas a la base de datos de nuestro portal Rexerve, exactamente a unas tablas que tenemos creadas únicamente para realizar pruebas pruebas. El contenido de estas tablas ha sido cedido por el portal al que estamos muy agradecidos, y que cuenta con más de 1500 alojamientos y más de 350 localidades Extremeñas. Resumiendo, disponemos de una magnifica base de datos de alojamientos de la región de Extremadura en España. (claro como Jorge y yo somo de allí, de dónde iban a ser si no) El desarrollo se basará en la creación de páginas JSP que muestren en pantalla el resultado de una consulta a una tabla llamada REX_ALOJAMIENTOS En la página se mostrarán los registros con la siguiente estructura: TIPO ALOJAMIENTO, NOMBRE ALOJAMIENTO, PROVINCIA, LOCALIDAD Es decir una consulta básica pero con relaciones entre tablas, ya que como vereis más adelante las tablas estarán formadas por campos PK (Primary Key) referenciadas entre sí, por dichos campos clave. También se harán otras consultas en base a peticiones del usuario, simulando así un escenario algo más real, lo que quiere decir que podremos, no sólo mostrar los registros, sino hacer búsquedas y filtros por provincia, localidad, nombre etc. Modelo de datos Antes de empezar a crear el famoso Bean de paginación, deberemos tener claro que este ejemplo que vamos a realizar consistirá en una consulta a unas tablas ya creadas en Oracle cuyos Scripts podeis encontrar a continuación: TABLA ALOJAMIENTOS CREATE TABLE ALOJAMIENTOS ( ID_TIPO_ALOJAMIENTO NUMBER (6), ID_PROVINCIA NUMBER (6), ID_AYUNTAMIENTO NUMBER (6), ID_ALOJAMIENTO NUMBER (6) NOT NULL, NOMBRE VARCHAR2 (50), CONSTRAINT PK_ALOJAMIENTOS PRIMARY KEY ( ID_ALOJAMIENTO ) ) ; TABLA PROVINCIAS CREATE TABLE PROVINCIAS ( ID_PROVINCIA NUMBER (6), PROVINCIA VARCHAR2 (50), CONSTRAINT PK_PROVINCIAS PRIMARY KEY ( ID_PROVINCIA ) ) ; Pág. 6 de 35

7 TABLA AYUNTAMIENTOS CREATE TABLE AYUNTAMIENTOS ( ID_PROVINCIA NUMBER (6), ID_AYUNTAMIENTO NUMBER (6), LOCALIDAD VARCHAR2(100), CONSTRAINT PK_AYUNTAMIENTOS PRIMARY KEY ( ID_AYUNTAMIENTO ) ) ; TABLA TIPO_ALOJAMIENTOS CREATE TABLE TIPO_ALOJAMIENTOS ( ID_TIPO_ALOJAMIENTO NUMBER (6) DESCRIPCION VARCHAR2 (100), IMAGEN VARCHAR2 (100), CONSTRAINT PK_TIPO_ALOJAMIENTOS PRIMARY KEY ( ID_TIPO_ALOJAMIENTO ) ) ; NOT NULL, Una vez creadas estas tablas tendremos el modelo de datos exactamente igual que el que voy a utilizar yo para hacer los ejemplos. Pág. 7 de 35

8 Contenido de las tablas Como hacer paginación con JSP. A continuación se muestra un ejemplo de los datos que hay en las tablas: Siento no poder poneros los Scripts de INSERT de todos los datos en las tablas pero, no puedo dejaros toda esta información, ya que nos ha sido cedida. Alojamientos Cómo ves está formado el tipo de alojamiento, la provincia, la localidad, el código único de cada alojamiento, y por supuesto del nombre de alojamiento. La tabla contiene registros. Ayuntamientos Esta tabla sólo contiene los datos básicos de una localidad, nuestros amigos de VerExtremadura.com, no nos han dado más información, de todos muchas gracias de nuevo, con el campo id_provincia, el campo único id_ayuntamiento y el nombre del municipio. La tabla contiene 382 registros. PROVINCIAS Pág. 8 de 35

9 Como ves la cosa más simple del mundo, dos registros con el nombre de las diferentes provincias que tiene la comunidad Extremeña. Tiene 2 registros. TIPO_ALOJAMIENTOS Esta tabla es también muy simple, pero tiene la particularidad de que dispone de un campo llamado Imagen, el cual contiene la dirección exacta dónde se encuentra las imágenes que después vamos a mostrar en pantalla, es decir en lugar de poner la descripción del tipo de alojamiento, pondremos la imagen que suele ser identificarse más con el tipo de alojamiento. Esta tabla tiene 12 registros. IMAGENES Estas imágenes te las puedes descargar haciendo clic aquí y debes ponerlas exactamente en el directorio images/ de tu servidor o de tu directorio virtual. Pág. 9 de 35

10 Comenzamos el trabajo Como hacer paginación con JSP. En este apartado tocaremos de forma detallada algunos aspectos a tener en cuenta a la hora de desarrollar el Bean, qué es, cómo funciona, los métodos y las propiedades. En nuestro directorio de classes, habitualmente ubicado en, /WEB-INF/classes guardaremos nuestro BeanPaginacion.java, y una vez allí compilarlo tantas veces cómo haga falta. El BeanPaginacion no es complicado de implementar, pero leer el código puede llegar a ser tedioso ya que verás muchos nombre de variables que a lo mejor no aparece claro que hace. Por eso, mucha gente, sobreentiende que funciona, se lo descarga, lo compila y luego lo usa. Totalmente de acuerdo, si algo funciona úsalo sin más. No creo que tengas demasiado tiempo para leerte todo lo referente al bean. Dos cosas importantes: 1. Si quieres hacer tu BeanPaginacion.java te recomiendo que leas con dedicación todo lo referente a las variables y los métodos del mismo. Te servirá de mucho comprender que hace cada fragmente de código en el caso de que tengas problemas para implementarlo. 2. Y dos, si no quieres saber como funciona el Bean y simplemente quieres usarlo, puedes descargártelo y pasar a leer con mucha atención, como hacer las páginas JSP que lo utilizan. Pág. 10 de 35

11 El BeanPaginacion.java El BeanPaginacion.java como cualquier otro Bean, empieza importando las clases necesarias, en esto caso, util,io y sql; y luego el propio nombre del fichero como constructor. import java.util.*; import java.io.*; import java.sql.*; public class BeanPaginacion{ Declaración de variables Entran a formar parte del Bean, numerosas variables que voy a detallar, más o menos, a continuación: //DECLARACIÓN DE VARIABLES //Variables de conexión a la base de datos. Connection cn = null; Statement s = null; boolean conectado; // Conectado si o no? //Datos de la conexión public String dburl = ""; public String pwd = ""; public String usuario = ""; // Variables para las funciones de Agregados, como un SUM // de algún campo numérico. String stragregados = ""; String strcadenafa = ""; // Variables globales para saber si existe un elemento o no y // auxiliar para guadar el target del enlace. boolean encontrado = false; String strtarget = ""; //Variable para guardar la cadena que mostrará el pie con los //número de página. String strcadenapaginas = ""; //Variables para los colores, está inicializados a mi gusto. Pág. 11 de 35

12 // Cambialos si lo deseas. String ColorFondoTabla = "#000066"; String ColorEncabezadoTabla = "#CCCCCC"; String ColorPieTabla = "#DDDDDD"; String ColorTextoFuncionesAgregado = "#123456"; String ColorTextoEncabezadoTabla = "#000000"; String ColorFilaImpar = "#FFFFFF"; String ColorFilaPar = "#EFEFEF"; String ColorFondoTitulo = "#000066"; String ColorTextoTitulo = "#FFFFFF"; String ColorTextoFilas = "#123456"; //Estas son genericas para el formateado de los resultados, como // el ancho de la tabla, el tamaño de la letra, el tipo de // letra etc. String stranchotabla = "70%"; String strtamanoletra = "2"; String strmensaje_no_hay_resultados = Sin datos"; String strhtml_no_resultados = ""; String strtitulo_rejilla = "Consulta"; String strfaceletra = "Verdana"; boolean bl_mostrar_paginaxdey = false; boolean bl_mostrar_paginas = true; // Quizá las más importantes son estas variables que son Arrays // de dos dimensiones. Se explicarán en detalle más adelante. String arcampos_ira[][]; String artitulo_campos[]; String arordenar_campos[][]; String arfagregados_campos[][]; String arnombres_campos[]; //Necesitamos una variable para saber por qué campo vamos a // contar el número de registros que hay en la consulta. String strcampocontarregistros = ""; //Al hacer clic en siguiente página o en anterior, hay que //decirle al Bean el nombre la página.se inicializa a prueba.jsp // pero es obligatorio poner el adecuado si quieres que // funcione. String que_pagina = "prueba.jsp"; //Variables que formaran la consulta. Muy importantes. String strselect = ""; String strfrom = ""; String strgroupby = ""; String strwhere = ""; String strorderby = ""; String enlace1,enlace2 = ""; boolean hay_orderby = false; //Variable para pasarle otros parámetros si hacen falta. // al estilo de &miparam1=valor1&miparam2=valor2 String strotrosparametros = "&"; Pág. 12 de 35

13 //Esta variable sigue aquí pero no implementaremos la impresión boolean imprimir = true; // Típica variable que me ayudará contar registros. int contador = 1; //Cuantos registros por página, se inicializa a 10. // Pero se puede cambiar claro. int registros = 10; //Esta variable, me dice en qué registro estamos, para mostrar //el resto a partir de él. int RegistroActual = 1; Hasta ahora sólo hemos visto como crear de cero el Bean, y las variables que necesitamos. Con lo que llevamos hasta ahora, que no es prácticamente nada, Quedaría de momento así: import java.util.*; import java.io.*; import java.sql.*; public class BeanPaginacion{ /* Declaración de variables aqui */ Pág. 13 de 35

14 Componentes del Bean Como hacer paginación con JSP. El BeanPaginacion.java, se compone de un constructor, funciones, métodos y propiedades. CONSTRUCTOR El constructor de una clase de Java, explicado básicamente, es lo primero que se ejecuta cuando un Bean es inicializado. Este contiene las instrucciones que necesitaremos para hacer correr nuestro Bean. El contructor quedará así: public BeanPaginacion() throws Exception { usuario pwd dburl Conectar(); = USUARIO_BASE_DATOS ; = PASSWORD_DE_BASE_DATOS ); = CADENA_URL_ORACLE_PARA_LA_CONEXION"); FUNCIONES GENERALES Las funciones son estas: Conectar La función Conectar, precisamente, inicializa las variables Cn y s con la conexión a la base de datos y el Statement principal que usaremos a lo largo del Bean. public void Conectar() throws Exception { conectado = true; try { Class.forName("oracle.jdbc.driver.OracleDriver"); cn = DriverManager.getConnection(dbURL, usuario, pwd) s = cn.createstatement(); catch(exception e) { conectado = false; throw e; Pág. 14 de 35

15 Hacer_CadenaNoDatos Como hacer paginación con JSP. Esta función crea un String con la cadena que queramos que salga en pantalla cuando no hay resultados en la consulta. Se puede hacer todo lo compleja o bonita que se quiera pero esta la vamos a hacer muy simple. public void Hacer_CadenaNoDatos() { strhtml_no_resultados= <P> ; strhtml_no_resultados+= strmensaje_no_hay_resultados; strhtml_no_resultados+= " <p> </p> "; Tiene_Registros Esta función tiene como finalidad, devolvernos true en caso de existan registros en la consulta o false, en caso contrario. public boolean TieneRegistros() { String strsql = ""; // SE CREA LA SELECT strsql=strselect; strsql+=strfrom; strsql+=strwhere; if (strgroupby!=null){ strsql+=strgroupby; strsql+=strorderby; boolean boltiene = false; int inttotalreg = 0; try { Statement s1 = cn.createstatement(); ResultSet rstotalregistros = s1.executequery("select count(" + strcampocontarregistros +") AS TOTAL_REGISTROS " + strfrom + strwhere ); if (rstotalregistros!= null){ rstotalregistros.next(); inttotalreg = rstotalregistros.getint("total_registros"); if (inttotalreg>0) boltiene=true; rstotalregistros.close(); s1.close(); catch(exception j){ return boltiene; Pág. 15 de 35

16 CerrarConexion Simplemente cierra la conexión cuando termina. public void CerrarConexion() { try { s.close(); cn.close(); catch(exception e){ Pág. 16 de 35

17 PROPIEDADES Como hacer paginación con JSP. Las propiedades, que yo las llamo así por su similitud a una clase de Visual Basic, son utilizadas para pasarle al Bean los parámetros necesarios antes de que muestre los registros en pantalla. Como por ejemplo el título del listado, el color de las filas impares, el de las pares, o bien el tipo de fuente o el tamaño que usará al imprimir los resultados en pantalla. Las propiedades cargan en las variables globales para el Bean, los datos que le pasemos desde la página JSP, así pues no voy a explicar cada propiedad ya que las variables están, a mi parecer, debidamente comentadas. Puedes guiarte por ellas para saber que hace cada propiedad. Estas son todas las propiedades del Bean: public void settextonohayresultados(string v_mensaje){ strmensaje_no_hay_resultados = v_mensaje; public void setotrosparametros(string v_otros){ strotrosparametros = v_otros; public void setanchotabla(string strancho){ stranchotabla = strancho; public void setcolorfondotabla (String RGBColor){ ColorFondoTabla = RGBColor; public void setcolorencabezadotabla (String RGBColor){ ColorEncabezadoTabla = RGBColor; public void settipoletra strfaceletra (String strtipoletra){ = strtipoletra; public void setcolorpietabla (String RGBColor){ ColorPieTabla = RGBColor; public void settamanoletra (String tamanio){ strtamanoletra = tamanio; public void setcolortextoencabezadotabla (String RGBColor){ ColorTextoEncabezadoTabla = RGBColor; public void setcolorfilaimpar (String RGBColor){ ColorFilaImpar = RGBColor; public void setcolorfilapar (String RGBColor){ ColorFilaPar = RGBColor; public void setcolortextofilas (String RGBColor){ ColorTextoFilas = RGBColor; public void setcolortextotitulo (String RGBColor){ ColorTextoTitulo = RGBColor; Pág. 17 de 35

18 public void setregistros_pagina(int intregistros){ registros = intregistros; public void setregistroactual(int intregistro){ RegistroActual = intregistro; public void settitulos_campos(string array_titulos_campos[]){ artitulo_campos = array_titulos_campos; public void setordenar_campo(string array_ordenar_campos[][]){ arordenar_campos = array_ordenar_campos; public void settitulo_rejilla(string strtitulo){ strtitulo_rejilla = strtitulo; public void setcamposira(string array_camposira[][]){ arcampos_ira = array_camposira; public String[][] getcamposira(){ return arcampos_ira; public void setpagina(string strpagina){ que_pagina = strpagina; public void setcampocontarregistros(string Campo){ strcampocontarregistros = Campo; public String getcampocontarregistros(){ return strcampocontarregistros; public void setfagregados_campo(string array1[][]){ arfagregados_campos = array1; public void setnombres_campos(string array_nombres_campos[]){ arnombres_campos = array_nombres_campos; public void setmostrar_paginaxdey(boolean SioNo){ bl_mostrar_paginaxdey = SioNo; public void setmostrar_paginas(boolean SioNo){ bl_mostrar_paginas = SioNo; public void setselect(string strselect1){ strselect = strselect1; public void setfrom(string strfrom1){ strfrom = strfrom1; public void setgroupby(string strgroupby1){ strgroupby = strgroupby1; public void setwhere(string strwhere1){ strwhere = strwhere1; Pág. 18 de 35

19 MÉTODOS Como hacer paginación con JSP. public void setorderby(string strorderby1){ strorderby = strorderby1; El más importante es el método Mostrar_Registros() que cómo su nombre indica es el que se encarga de imprimir los resultados y además de evaluar todos los parámetros que han sido pasados previamente. El único método que tiene el Bean es precisamente la parte más importante del mismo, ya que es el que te pondrá los datos en pantalla. Se llama Mostrar_Registros() Pág. 19 de 35

20 La página JSP Cómo tenemos casi todo el Bean creado, a falta del método, Mostrar_Registros(), vamos a hacer una pausa para empezar a ver cómo quedaría la página JSP, mediante el ejemplo que aparece en este tutorial. Nos detendremos en cada apartado de la página JSP para explicar a fondo lo que hace cada línea y los parámetros que se le pasan al Bean para que este, funcione adecuadamente. El código de la página JSP, no es especialmente difícil, si se conoce cómo funciona el Bean, ya que únicamente es rellenar las variables, establecerlas y llamar al método Mostrar_Registros(). Enumeraré en poco pasos, como debería ir quedando la página JSP. Son estos: 1.Cabecera de página. 2.JavaScript. 3.Posicionamiento y dirección del cursor. 4.Cláusula SELECT. 5.Nombre y Títulos de los campos 6.Campo clave. 7.Otras variables importantes. 8.Clic en los campos para detalles del registro 9.Ordenación. 10. Mostrar registros y cierre 1.Cabecera de página Lo primero de todo es incluir las líneas necesarias para decirle a la página JSP que utilice el Bean, son estas: <%@ page language="java" import="java.sql.*,java.io.*,java.util.*" %> <jsp:usebean id="mibeanprueba" class="beanpaginacion" scope="page"> <jsp:setproperty name="mibeanprueba" property="*"/> </jsp:usebean> Cómo deberías saber, para llamar a un Bean, necesitas la instrucción <jsp:usebean..> No voy a entrar a explicar cómo se establece la conexión con un Bean, ni los parámetros, tanto opcionales como obligatorios en dicha llamada, ya que no es materia de este tutorial. Simplemente yo lo hago así. Pág. 20 de 35

21 2. JavaScript Una parte fundamental de la página JSP para que el efecto de resaltado de cada línea tenga efecto son unas instrucciones de JavaScript que debe ir al principio de cada página, entre los tagas, <head> y </head> Un ejemplo de código sería este: <html> <head> <title>ejemplo de Paginación. Rexerve.com</title> <SCRIPT LANGUAGE="JavaScript"> <!-- function dentro(origen,color) { if (!origen.contains(event.fromelement)) { // origen.style.cursor = 'hand'; origen.bgcolor = Color; function salir(origen,color2) { if (!origen.contains(event.toelement)) { origen.style.cursor = 'default'; origen.bgcolor = Color2; function hacer_click(origen) { if(event.srcelement.tagname=='tr'){ origen.children.tags('a')[0].click(); // --> </SCRIPT> </head> Gracias a estas líneas, al poner el cursor sobre cualquier línea de los datos, dicha línea, se resaltará con un color que puede personalizarse a gusto del consumidor. Aunque lo ideal es meter este código dentro de un archivo de Script.js puede ponerlo en todas las páginas si lo deseas. 3. Posicionamiento y dirección del cursor. A continuación debemos recoger los parámetros que el propio Bean nos envía. Estos parámetros son el Registro por dónde quieres empezar a mostrar registros y otro es la dirección a dónde queremos dirigirnos, es decir hacia delante o hacia atrás. El código quedaría asi: <%// INICIALIZA EL REGISTRO EN EL QUE DEBE POSICIONARLE LA PRIMERA VEZ // QUE SE ENTRA EN LA PAGINA. // **************************************************** int RegistroActual = 1; String v_direccion = ""; // RECOGE EL PAREMETRO POR SI SE HA MOVIDO DE PAGINA // ************************************************** try { if (request.getparameter("actual")!= null) RegistroActual = Integer.parseInt(request.getParameter("Actual")); catch(exception e) { RegistroActual = 1; Pág. 21 de 35

22 // RECOGE EL PAREMETRO DE DIRECCION // ********************************** try { if (request.getparameter("direccion")!= null) v_direccion = request.getparameter("direccion"); catch(exception e) { v_direccion = null; String empezar = request.getparameter("actual"); if (empezar==null) empezar=""; //VARIABLE PARA EL REGISTRO ACTUAL DONDE SE ENCUENTRA // SI SE LE HA PASADO PARAMETRO DE BUSQUEDA SE LE PONE AL // RegistroActual if (!(empezar.equals(""))){ if (Integer.parseInt(empezar) <= 0) RegistroActual = 1; else RegistroActual = Integer.parseInt(empezar); %> A partir de estas líneas de código estamos en disposición para empezar a pasarle parámetros al BeanPaginacion. 4. Cláusula SELECT Ahora vamos a establecer las opciones de la SELECT, para ello contamos con 4 variables importantes, que además deben estar siempre creadas y establecidas, si no es así no funcionará correctamente. El siguiente fragmento de código quedará asi: <% // VARIABLES PARA FORMAR LA SELECT COMPLETA // **************************************************** String strselect = ""; String strfrom = ""; String strwhere = ""; String strorderby = ""; // SE CREA LA SENTENCIA 'SELECT', EL 'FROM', LA 'WHERE' Y EL // 'ORDER BY' // ****************************************************** strselect=" SELECT ALOJAMIENTOS.ID_ALOJAMIENTO AS CODIGO,"; strselect+=" '<img src=\"' TIPO_ALOJAMIENTOS.IMAGEN '\">' AS IMAGEN,TIPO_ALOJAMIENTOS.DESCRIPCION AS DESCRIPCION,ALOJAMIENTOS.NOMBRE AS NOMBRE, "; strselect+=" PROVINCIAS.PROVINCIA AS PROVINCIA,AYUNTAMIENTOS.LOCALIDAD AS MUNICIPIO"; strfrom=" FROM ALOJAMIENTOS,TIPO_ALOJAMIENTOS,PROVINCIAS,AYUNTAMIENTOS "; strwhere=" WHERE ALOJAMIENTOS.ID_AYUNTAMIENTO=AYUNTAMIENTOS.ID_AYUNTAMIENTO "; Pág. 22 de 35

23 strwhere+=" AND ALOJAMIENTOS.ID_PROVINCIA =PROVINCIAS.ID_PROVINCIA"; strwhere+=" AND PROVINCIAS.ID_PROVINCIA = AYUNTAMIENTOS.ID_PROVINCIA "; strwhere+=" AND ALOJAMIENTOS.ID_TIPO_ALOJAMIENTO=TIPO_ALOJAMIENTOS.ID_TIPO_ALOJAMIENTO "; strorderby=" ORDER BY ALOJAMIENTOS.NOMBRE "; %> <%// SE ESTABLECEN LA SELECT, LA FROM, LA WHERE Y EL ORDER BY // **************************************** mibeanprueba.setselect(strselect); mibeanprueba.setfrom(strfrom); mibeanprueba.setwhere(strwhere); mibeanprueba.setorderby(strorderby); %> 5. Nombres y Títulos de los campos Para que el Bean sepa cuales son los campos que necesita sabes, y para puedas imprimir solo aquellos que de verdad quieres que muestre, permitiendo hacer así una SELECT con más campos por si lo necesitas para algo, tiene que especificarle que campos quieres que muestre; esto se hace con este código: <%//ARRAY CON LOS NOMBRES DE LOS CAMPOS QUE SE QUIEREN MOSTRAR //********************************************************** String[] array_nombres_campos= new String[4]; array_nombres_campos[0] = "IMAGEN"; array_nombres_campos[1] = "NOMBRE"; array_nombres_campos[2] = "PROVINCIA"; array_nombres_campos[3] = "MUNICIPIO"; mibeanprueba.setnombres_campos(array_nombres_campos); %> Procura que coincidan con los de la SELECT, es totalmente obligatorio ya que si no lo es así te dirá que no encuentra el campo en la cláusula. Títulos de los campos. Los nombre de los campos no siempre coinciden con lo que de verdad quieres que escriba en pantalla, a decir verdad, casi nunca coincidirán. Por ejemplo es muy común que en la cabecera de la columna COD_REGISTRO, quieras poner CODIGO simplemente. Por este motivo he separado en dos Arrays los nombres de los campo de los nombres de las columnas. Para establecer la descripción de las columnas puedes escribir el siguiente código: <% //ARRAY CON LOS TITULOS DE LOS CAMPOS QUE APARECEN //************************************************ String[] array_titulos_campos = new String[4]; array_titulos_campos[0] = "Tipo"; array_titulos_campos[1] = "Alojamiento"; array_titulos_campos[2] = "Provincia"; array_titulos_campos[3] = "Localidad"; mibeanprueba.settitulos_campos(array_titulos_campos); %> Pág. 23 de 35

24 6. Campo clave Es muy importante, tener un campo clave único para que el Bean pueda saber cuantos registros tiene la consulta y así saber cuantas páginas tiene que mostrar en los resultados. Para ello debes establecer cual es campo clave o Primary Key de tu consulta, en este ejemplo es ALOJAMIENTOS.ID_ALOJAMIENTO: <%//CAMPO QUE SE UTILIZA PARA SABER CUANTOS REGISTROS TIENE LA SELECT //************************************************** mibeanprueba.setcampocontarregistros("alojamientos.id_alojamiento"); %> 7. Otras variables importantes Otros datos importantes serán el número de registros que deseas poner en cada pantalla, el ancho de la tabla con los resultados y el nombre de la página JSP. Para establecer estos valores sólo debes escribir las siguiente líneas de código: <% // SE ESTABLECEN EL NUMERO DE REGISTROS POR PAGINA // *********************************************** mibeanprueba.setregistros_pagina(5); // A QUE PAGINA TIENE QUE IRSE CUANDO HACE LA PAGINACIÓN // ES EL MISMO NOMBRE QUE ESTA PAGINA // ***************************************************** mibeanprueba.setpagina("ejemplo_paginacion2.jsp"); // ANCHO DE LA TABLA CON LOS RESULTADOS // ***************************************************** mibeanprueba.setanchotabla("500"); //PIXELS. TAMBIEN PUEDES PONER POR EJEMPLO 80% //SE LE PASA EN QUE REGISTRO SE QUIERE EMPEZAR A MOSTRAR DATOS //************************************************************* mibeanprueba.setregistroactual(registroactual); //TITULO DE LA REJILLA //********************* mibeanprueba.settitulo_rejilla("cabecera de la consulta"); %> 8. Clic en los campos para detalles del registro. Al mostrar registros en pantalla lo más habitual es que necesitemos hacer clic en alguna parte para irnos a otra página y mostrar detalle por ejemplo, o bien mostrar otra página que disponga de más información. Para ello he habilitado una propiedad especial que permitirá hacer este proceso :SetCampoIrA. SetCampoIrA, es una propiedad a la que deberás pasar siempre un Array con al menos 4 elementos, el nombre del campo que cogerá como valor del parámetro, el nombre del parámetro, el título del campo de los mostrados en pantalla que utilizará para hacer el clic y por último la página a la que debe irse. <% /* ******************************************************* Pág. 24 de 35

25 COMO CONSTRUIR EL ARRAY DE IR A --> IMPORTANTE QUE ESTE ARRAY TENGA INFORMACION CORRECTA array_camposira[n][0] = "CODIGO"; --> nombre del campo que coge como valor del parametro; array_camposira[n][1] = "id"; --> nombre del parametro array_camposira[n][2] = NOMBRE"; --> campo de los mostrados que se utiliza para hacer el link array_camposira[n][3] = "detalles1.jsp"; --> pagina a la que se va SI EL ENLACE A OTRA PAGINA TIENE MAS DE UNA PARAMETRO BASTA CON AGREGAR UN ELEMENTO MAS AL ARRAY CON EL MISMO NOMBRE DE CAMPO QUE VINCULA PERO CON DISTINTO NOMBRE DE PARAMETRO Y DISTINTO VALOR DE CAMPO EN EL EJEMPLO, EL ELEMENTO 0 Y 1 DEL ARRAY UTILIZAN EL MISMO CAMPO DE LINK Y TIENE DOS PARAMETRO QUE SE LE PASA A LA PAGINA detalles1.jsp ****************************************************** */ String[][] array_camposira = new String[3][4]; array_camposira[0][0] = "CODIGO"; array_camposira[0][1] = "id_alojamiento"; // --> SI HAY DOS IGUALES LOS COGERÁ JUNTOS array_camposira[0][2] = "NOMBRE ; array_camposira[0][3] = " detalles1.jsp"; %> mibeanprueba.setcamposira(array_camposira); 9. Ordenación. Otro aspecto que puede ser importante es la ordenación, para poder ordenar la consulta por alguno de los campos puedes utilizar la propiedad setordenar_campo(). Aquí tienes un ejemplo de cómo se usa. <% //ARRAY CON LOS NOMBRES DE LOS CAMPOS QUE PERMITEN ORDENACION //************************************************ String[][] array_ordenar_campos = new String[1][2]; array_ordenar_campos[0][0] = "Alojamiento";// --> título del campo array_ordenar_campos[0][1]= "NOMBRE";// ---> nombre del campo mibeanprueba.setordenar_campo(array_ordenar_campos); %> 10. Mostrar registros y cierre. Por último debemos llamar al método que hace que todo funcione que es, el ya fomoso, Mostrar_Registros(). Aunque todavía no lo hemos explicado, (ya lo haremos), es el motor que hace funcionar todo. Deberás poner esta líneas de código de esta forma: <% //MOSTRAR LOS RESULTADOS EN PANTALLA //********************************* %> Pág. 25 de 35

26 <%=mibeanprueba.mostrar_registros()%> </body> </html> La verdad es que entender todo lo que hemos visto hasta ahora, puede llevarte tiempo. Así que puedes ver y descargarte todo el código de la página JSP siguiendo este enlace : /rexerve/samples/ejemplo_paginacion.txt O bien si deseas ver un ejemplo de lo que hace esta página jsp, dirígete a: /rexerve/ejemplo_paginacion2.jsp Pág. 26 de 35

27 El método Mostrar_Registros() Por fin llegamos al último capítulo de este tutorial y lo hacemos mostrando el código que consigue mostrar los registros en pantalla, teniendo en cuenta todos los parámetros que le hemos pasado desde la página JSP. El método Mostrar_Registros(), como su propio nombre indica, es el encargado de elaborar la Select, en base a las variables strselect, strfrom, strwhere y strorderby, una simple concateneción basta para formar la cláusula, y empezar, después, a recorrer los registros des el registro marcado como RegistroActual. No es difícil de entender, pero si de hacer, ya que además de poner los registros en la página de una forma coherente y paginada, tiene que saber, por ejemplo en campo se tiene que hacer un clic, y que página ir, y además que parámetros pasarle a dicha págia. O bien saber si tiene que hacer ordenación por un campo u otro. Se utilizan algunas imágenes que puedes encontrar justo debajo. y además un punto transparente de 1x1 pixels. Puedes descargártelas de : Como se que ahí es difícil de leer, tienes el Bean completo en la dirección: En fin aquí el va todo el código de este método: public String Mostrar_Registros(){ String strsql = ""; String strcadena = ""; int contador = 1; int i = 0; // CREO LA SELECT strsql=strselect; strsql+=strfrom; strsql+=strwhere; //GROUP BY 25/02/2002 if (strgroupby!=null){ strsql+=strgroupby; strsql+=strorderby; try { // ***************************************** // SACA LOS DATOS PARA LAS FUNCIONES DE AGREGADO. Pág. 27 de 35

28 // ***************************************** Statement sfa = cn.createstatement();; ResultSet rsagregados ; if (arfagregados_campos!= null){ for (int mk=0;mk<arfagregados_campos.length;mk++){ stragregados = "SELECT "; stragregados+= "'<div align=\""+arfagregados_campos[mk][4]+"\">' TO_CHAR("+arFAgregados_Campos[mk][2]+ "(" +arfagregados_campos[mk][1]+"),'99,999,999,990.90') '</div>' "; stragregados+=strfrom; stragregados+=strwhere; rsagregados = sfa.executequery(stragregados); if (rsagregados!= null){ rsagregados.next(); arfagregados_campos[mk][3] = rsagregados.getstring(1); // CALCULA EL NUMERO DE PAGINAS QUE HAY EN LA SELECT rsagregados.close(); // ***************************************** // SACA EL NUMERO DE REGISTROS DE LA TABLA // ***************************************** int inttotalreg = 0; Statement s1 = cn.createstatement(); ResultSet rstotalregistros = s1.executequery("select count(" + strcampocontarregistros +") AS TOTAL_REGISTROS " + strfrom + strwhere ); if (rstotalregistros!= null){ rstotalregistros.next(); inttotalreg = rstotalregistros.getint("total_registros"); // CALCULA EL NUMERO DE PAGINAS QUE HAY EN LA SELECT // *************************************************** int Total_Paginas = 0; if (inttotalreg > 0){ Total_Paginas = inttotalreg / registros; if (inttotalreg % registros >0) Total_Paginas ++; rstotalregistros.close(); s1.close(); // FIN DEL REGISTROS DE LA TABLA // ***************************** { if (inttotalreg >0 && (RegistroActual >=1) ) strcadena+="<table width='"+stranchotabla+"' border='0' cellspacing='2' cellpadding='1' align='center'>"; strcadena+=" <tr bgcolor='"+colorfondotabla+"'> "; strcadena+=" <td> "; Pág. 28 de 35

29 strcadena+="<table width='100%' border='0' cellspacing='1' cellpadding='3' align='center'>"; strcadena+=" <tr background=\"images/top_nav.jpg\" bgcolor='"+colorfondotitulo+"'> "; if( imprimir ) { strcadena+=" <td background=\"images/top_nav.jpg\" colspan='"+arnombres_campos.length+"'><b><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextotitulo+"'><b>" + strtitulo_rejilla + "</b></font></b></td>"; else { strcadena+=" <td colspan='"+(arnombres_campos.length- 1)+"'><b><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextotitulo+"'><b>" + strtitulo_rejilla + "</b></font></b></td>"; //strcadena+=" <td align='right'><a href='imprimir_busqueda.jsp?formulario=1'><image src='images/printer2a.gif' border='0' alt='versión imprimible'></a></td>"; strcadena+="</tr>"; strcadena+=" <tr> "; //el order by pasado por el array hay_orderby=false; for (int k=0;k<artitulo_campos.length;k++){ strcadena+="<td bgcolor='" +ColorEncabezadoTabla+"'><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextoencabezadotabla+"'><b>" + artitulo_campos[k] + "</b></font>"; try { for (int mm=0;mm<arordenar_campos.length;mm++){ if (artitulo_campos[k].equals(arordenar_campos[mm][0])){ strcadena+="<a href="+que_pagina+"?orderby=order%20by%20"+arordenar_campos[mm][1]+str OtrosParametros+"><img width=\"20\" height=\"17\" align=\"absmiddle\" alt=\"ordenar Ascendente\" border=\"0\" src=\"images/order_down1.gif\"></a> <a href="+que_pagina+"?orderby=order%20by%20"+arordenar_campos[mm][1]+"%2 0DESC"+strOtrosParametros+"><img border=\"0\" width=\"16\" height=\"17\" align=\"absmiddle\" src=\"images/order_up1.gif\" alt=\"ordenar descendentemente\"></a>"; catch(exception e){ strcadena+="</td>"; strcadena+=" </tr>"; //**************************************************************** *********** //PONE LOS RESULTADOS DE LAS FUNCIONES DE AGREGADO EN UNA CADENA. strcadenafa Pág. 29 de 35

30 //**************************************************************** *********** try{ if (arfagregados_campos.length>0) strcadenafa=" <tr> "; catch(exception j){ for (int yk=0;yk<artitulo_campos.length;yk++){ try { encontrado = false; for (int sa=0;sa<arfagregados_campos.length;sa++){ if (artitulo_campos[yk].equals(arfagregados_campos[sa][0])){ encontrado = true; strcadenafa+="<td bgcolor='" +ColorEncabezadoTabla+"'><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextofuncionesagregado+"'><b>" + arfagregados_campos[sa][3] + "</b></font>"; if (!(encontrado)) strcadenafa+="<td bgcolor='" +ColorEncabezadoTabla+"'><img src=\"images/punto_trans.gif\">"; try{ catch(exception e){ strcadenafa+="</td>"; if (arfagregados_campos.length>0) strcadenafa+=" </tr> "; catch(exception j){ ResultSet rs = s.executequery(strsql); if (inttotalreg >0 && (rs.next() RegistroActual >=1) ) { int contador_registros = 1; int pagina = 1; int registros_anteriores = 1; //**************************************************************** ****** //SABER LOS REGISTROS ANTERIORES Y Y LA PAGINA EN LA QUE ESTA EL USUARIO //**************************************************************** ****** while (registros_anteriores < RegistroActual) { rs.next(); registros_anteriores++; //CALCULA QUE PAGINA SE ESTA MOSTRANDO //************************************** if (contador_registros >= registros) { contador_registros = 0; pagina++; //VARIABLE CUYO VALOR ES LA PAGINA EN LA QUE EST\u00c1 Pág. 30 de 35

31 Como hacer paginación con JSP. contador_registros++; //********************** //PAGINAS DE LA CONSULTA //********************** int inicio = 1; // SE CALCULA EN QUE PAGINA DEBE EMPEZAR LA CADENA DE PAGINAS // ********************************************************** if ( pagina > 10 ) inicio = pagina - 5; else if (pagina==10) inicio = 9; int contador_paginas = 1; // HAGO LA CADENA QUE SIRVE PARA MOSTRAR LAS PAGINAS // *************************************************** for (int y=inicio;y<=total_paginas;y++){ if (y!= pagina) strcadenapaginas+="<a href='" +que_pagina +"?Actual=" + String.valueOf((y*registros)+1- registros)+"&direccion=s&orderby="+strorderby+strotrosparametros+"'>"; else strcadenapaginas+="<b><font size='"+strtamanoletra+"' face='"+strfaceletra+"'>["; strcadenapaginas+=y; if (y!= pagina) strcadenapaginas+="</a>"; else strcadenapaginas+="]</font></b>"; if (y!=total_paginas) strcadenapaginas+=" "; contador_paginas++; if (contador_paginas >10) break; // si ya se que queda un poco mal pero me la suda!! // REGISTROS DE LA CONSULTA // *********************** do { if (i==0){ strcadena+="<tr bgcolor='" + ColorFilaImpar +"' onclick=\"hacer_click(this)\" onmouseout=\"salir(this,'"+colorfilaimpar+"');\" onmouseover=\"dentro(this,'#efef99');\">"; i=1; else { strcadena+="<tr bgcolor='" + ColorFilaPar + "' onclick=\"hacer_click(this)\" onmouseout=\"salir(this,'"+colorfilapar+ "');\" onmouseover=\"dentro(this,'#efef99');\">"; i=0; Pág. 31 de 35

32 CAMPO Como hacer paginación con JSP. for (int j=0;j<arnombres_campos.length;j++){ enlace1= ""; enlace2= ""; //SE CONTROLA SI HAY QUE PONER <A HREF..> EN EL boolean hay_mas; int g=0; int h=0; while (g<arcampos_ira.length){ // SI HAY QUE PONER UN LINK... if (arcampos_ira[g][2] == arnombres_campos[j]){ hay_mas = false; strtarget=""; try{ if (arcampos_ira[g][4]!= null){ strtarget = " target="+arcampos_ira[g][4]; catch(exception e){ enlace1 = "<a "+strtarget+" href="+ arcampos_ira[g][3]+ "?" + arcampos_ira[g][1] + "=" + rs.getstring(arcampos_ira[g][0]); h=g+1; // PUEDE QUE TENGA MAS PARAMETROS EN LA LLAMADA A LA PAGINA... while (h<arcampos_ira.length){ if (arcampos_ira[h][2] == arnombres_campos[j]){ hay_mas = true; enlace1+="&" + arcampos_ira[h][1] + "=" + rs.getstring(arcampos_ira[h][0]); h++; if (hay_mas) g=h-1; enlace1+= strotrosparametros+ ">"; enlace2= "</a>"; g++; // SE EVITAN LOS NULOS EN LOS ENLACES if (enlace1==null) enlace1= ""; if (enlace2==null) enlace2= ""; // SE IMPRIME LA FILA CON EL VALOR strcadena+="<td><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextofilas+"'>" + enlace1 + rs.getstring(arnombres_campos[j]) + enlace2+"</font></td>"; strcadena+="</tr>"; contador++; while ( contador<=registros && rs.next() ); //SE IMPRIME LAS FUNCIONES DE AGREGADO try { if (arfagregados_campos.length>0) strcadena+=strcadenafa; Pág. 32 de 35

33 catch(exception j){ //PIE DE LA TABLA 1 --> PAGINA 1 DE n //************************************* if (bl_mostrar_paginaxdey){ strcadena+=" <tr> "; strcadena+="<td colspan='"+ artitulo_campos.length+1 +"' bgcolor='" +ColorPieTabla+"'><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextoencabezadotabla+"'>p\u00e1gina " + pagina + " de " + Total_Paginas+"</font></td>"; strcadena+="</tr> "; //PIE DE LA TABLA --> P\u00e1gina : n //********************************************************* if ((bl_mostrar_paginas) && (Total_Paginas >= pagina)) { strcadena+=" <tr> "; strcadena+="<td colspan='"+ artitulo_campos.length+1 +"' bgcolor='" +ColorPieTabla+"' align='center'><font size='"+strtamanoletra+"' face='"+strfaceletra+"' color='"+colortextoencabezadotabla+"'>" + strcadenapaginas + "</font></td>"; strcadena+="</tr> "; strcadena+="</table>"; strcadena+=" </td></tr></table>"; // *********************************************** // SE CALCULA SI HAY QUE PONER ANTERIOR Y/o SIGUIENTE // *********************************************** String StrNavegacion = ""; StrNavegacion+= "<table width='508' border='0' cellspacing='2' cellpadding='1' align='center'>"; StrNavegacion+= "<tr align='center'> "; if (RegistroActual >= registros + 1){ StrNavegacion+= "<td width='220'> "; StrNavegacion+= "<div align='right'><a href='"+que_pagina+"?actual="+string.valueof(registroactualregistros)+"&direccion=ant&orderby="+strorderby+strotrosparametros+"'> "; StrNavegacion+= "<font size='"+strtamanoletra+"' face='"+strfaceletra+"' ><img src='images/back.gif' border='0' alt='"+registros+" registros anteriores'></font></a> </div>"; StrNavegacion+= "</td>"; else { StrNavegacion+= "<td width='220'>\u00a0\u00a0 </td>"; StrNavegacion+= "<td width='220'>\u00a0\u00a0 </td>"; if ( (contador - 1 < inttotalreg) && (RegistroActual == 1) ){ StrNavegacion+= "<td ' width='220'>"; StrNavegacion+= "<div align='left'><a href='"+que_pagina+"?actual="+string.valueof(registroactual+registros) +"&Direccion=Sig&orderby="+strOrderBy+strOtrosParametros+"'>"; Pág. 33 de 35

34 StrNavegacion+= "<font size='"+strtamanoletra+"' face='"+strfaceletra+"'><img src='images/next.gif' border='0' alt='"+registros+" registros siguientes'></font></a> </div>"; StrNavegacion+= "</td>"; else { if (RegistroActual contador - 1 < inttotalreg){ StrNavegacion+="<td width='220'> "; StrNavegacion+= "<div align='left'><a href='" + que_pagina+"?actual="+string.valueof(registroactual+registros)+"&direc cion=sig&orderby="+strorderby+strotrosparametros+"'> "; StrNavegacion+= "<font size='"+strtamanoletra+"' face='"+strfaceletra+"' ><img src='images/next.gif' border='0' alt='"+registros+" registros siguientes'></font></a> </div>"; StrNavegacion+= "</td>"; else { StrNavegacion+= "<td >\u00a0 </td> "; StrNavegacion+= "</tr>"; StrNavegacion+= "</table>"; strcadena+=strnavegacion; else{ Hacer_CadenaNoDatos(); strcadena = strhtml_no_resultados; rs.close(); catch(exception e) { strmensaje_no_hay_resultados = "<P><b><font size='3' face='"+strfaceletra+"' color='#ff1111'>se ha producido el siguiente error:</font></b><p><font size='"+strtamanoletra+"' face='"+ strfaceletra + "' color='"+ ColorTextoEncabezadoTabla+"'>" + e + "</p>"; Hacer_CadenaNoDatos(); //strmensaje_no_hay_resultados = "<p><b>se ha producido un error:</b><p>"+e+"</p>"; strcadena = strhtml_no_resultados; e.printstacktrace(); return strcadena; Pág. 34 de 35

35 Consideraciones finales Resumen Como hacer paginación con JSP. En los primeros capítulos hemos dado un repaso a lo que es la paginación y el material necesario para crear las tablas y los datos, además de las imágenes necesarias. Posteriormente, nos hemos ido adentrando en cómo se crean las propiedades, funciones y la propia página Jsp que llama al Bean. Y como hemos visto al final, te he puesto el método Mostrar_Registros() que es el que desempeña la función principal de mostrar registros. Qué no hemos visto? Como mucho de vosotros ya sabeis, un método que se usa para hacer paginación de registros el método Absulte(), que permite posicionarle en un Statement, en algún registro determinado. Este método no se ha usado en este tutorial. Pág. 35 de 35