¿Cómo implementar la tecnología de paginación en JSP?
título: implementación de la tecnología de paginación JSP
resumen: uso de clases de herramientas para implementar el procesamiento de paginación general
autor: evan_zhao
correo electrónico: evan_zhao @ hotmail.com
El método de paginación más utilizado actualmente es almacenar en caché los resultados de la consulta en HttpSession o beans con estado, y al pasar la página, se saca una página de datos del caché y se muestra. Este método tiene dos desventajas principales: en primer lugar, el usuario puede ver datos caducados; en segundo lugar, si la cantidad de datos es muy grande, llevará mucho tiempo recorrer el conjunto de resultados de la primera consulta y los datos almacenados en caché también tardarán mucho tiempo. consume mucha memoria, la eficiencia disminuye significativamente.
Otros métodos comunes incluyen consultar la base de datos cada vez que se pasa la página y sacar solo una página de datos del ResultSet (use rs.last(); rs.getRow() para obtener el número total de registros, utilice rs.absolute() localiza el registro inicial de esta página). Este método casi requiere atravesar todos los registros en la implementación JDBC de algunas bases de datos (como Oracle. Los experimentos han demostrado que la velocidad es muy lenta cuando la cantidad de registros es grande).
En cuanto al método de almacenamiento en caché del ResultSet, es completamente incorrecto. Debido a que el ResultSet también se cerrará cuando se cierre la Declaración o la Conexión, para que el ResultSet sea efectivo, ocupará la conexión de la base de datos durante mucho tiempo.
Por lo tanto, una mejor práctica de paginación debería ser recuperar solo fragmentos de datos del tamaño de una página de la base de datos cada vez que se pasa la página. De esta manera, aunque es necesario consultar la base de datos cada vez que se pasa la página, la cantidad de registros consultados es muy pequeña y la cantidad de datos transmitidos a través de la red no es grande. Si se utiliza un grupo de conexiones, la mayor parte del tiempo. Se puede omitir el largo proceso de establecer una conexión a la base de datos. En el lado de la base de datos, existen varias tecnologías de optimización maduras que se utilizan para mejorar la velocidad de las consultas, que son mucho más efectivas que el almacenamiento en caché en la capa del servidor de aplicaciones.
El número de fila del resultado de la consulta en la base de datos Oracle está representado por la pseudocolumna ROWNUM (comenzando desde 1). Por ejemplo, seleccione * del empleado donde rownumlt; 10 devuelve los primeros 10 registros. Pero debido a que rownum se asigna después de consultar y antes de ordenar, la consulta de los registros 100.º a 120.º de empleado ordenados por cumpleaños debe escribirse así:
[pre] select * from (
select my_table.*, rownum as my_rownum from (
seleccione nombre, cumpleaños del empleado ordenar por cumpleaños
) my_table donde rownum lt;
) donde my_rownumgt ; =100
[/pre]
MySQL puede usar la cláusula LIMIT:
seleccione nombre, cumpleaños del empleado ordene por cumpleaños LIMIT 99, 20
p>
DB2 tiene la función número de fila() para obtener el número actual de filas.
SQL Server no ha sido estudiado, puedes consultar este artículo: Words
///////////////////// /// ////////////
//
// Page.java
// autor: evan_zhao@hotmail .com
//
//////////////////////////////// /////
página del paquete
importar java.util.List;
importar java.util.ArrayList
importar java.util. Colección
importar java.util.Collections
/**
* Título: objeto de paginación
* Descripción: Objeto utilizado para contener datos e información de paginación lt; brgt;
* La clase Page implementa el método básico para mostrar información de paginación, pero no especifica el tipo de datos contenidos.
* Las subclases que organizan datos de formas específicas se pueden implementar según sea necesario, lt; brgt;
* Por ejemplo, RowSetPage usa RowSet para encapsular datos y ListPage usa List para encapsular datos lt; brgt;
* Copyright: Copyright (c) 2002 lt; brgt;
* @autor evan_zhao@hotmail.com brgt; 1.0
*/
Página de clase pública implementa java.io.Serializable {
Página final estática pública EMPTY_PAGE = nueva página(); p>public static final int DEFAULT_PAGE_SIZE = 20;
public static final int MAX_PAGE_SIZE = 9999
private int myPageSize = DEFAULT_PAGE_SIZE
private int start; /p>
privado int avaCount, totalSize;
datos del objeto privado
privado int currentPageno
privado int totalPageCount
/**
* Método de construcción predeterminado, solo construye páginas vacías
*/
página protegida(){
this .init(0, 0, 0 , DEFAULT_PAGE_SIZE, new Object());
}
/**
* Método inicial de paginación de datos, llamado por subclases
* @param start La posición inicial de los datos de esta página en la base de datos
* @param avaCount El número de elementos de datos contenidos en esta página
* @
param totalSize El número total de registros en la base de datos
* @param pageSize La capacidad de esta página
* @param data Los datos contenidos en esta página
*/
protected void init(int start, int avaCount, int totalSize, int pageSize, datos del objeto){
this.avaCount =avaCount
this; .myPageSize = tamaño de página;
this.start = inicio;
this.totalSize = totalSize
this.data=datos; >//System.out.println("avaCount:" avaCount);
//System.out.println("totalSize:" totalSize
if (avaCountgt;totalSize); ) {
//throw new RuntimeException("¡¿El número de registros es mayor que el número total?!");
}
this.currentPageno = (inicio -1)/tamaño de página 1
this.totalPageCount = (tamaño total de página -1) / tamaño de página
if (tamaño total==0 amp; amp; avaCount==0; ){
this.currentPageno = 1;
this.totalPageCount = 1
}
//System.out.println ("Iniciar índice de página número: " start "-" currentPageno
}
objeto público getData(){
return this.data; /p>
}
/**
* Obtener la capacidad de datos de esta página (el número de registros que esta página puede contener)
* @return el número de registros que puede contener esta página
*/
public int getPageSize(){
return this.myPageSize
;}
/**
* Si hay una página siguiente
* @return Si hay una página siguiente
*/
público booleano hasNextPage() {
/*
if (avaCount==0 amp; amp; totalSize==0){
return false;
}
return (start avaCount -1) lt;totalSize; retorno (this.getCurrentPageNo()lt; this.getTotalPageCoun
t());
}
/**
* Si hay una página anterior
* @return Si hay una página anterior Página
*/
public boolean hasPreviousPage() {
/*
return start gt
*/
return (this.getCurrentPageNo()gt; 1
}
/**
* @return
*/
public int getStart(){
return start;
}
/**
* Obtener la posición del último dato de la página actual en la base de datos
* @return
*/
public int getEnd(){
int end = this.getStart() this.getSize() -1;
if (endlt; 0) {
fin = 0;
}
retorno final
}
/**
* Obtener la posición del primer dato en la página anterior en la base de datos
* @return el rownum correspondiente a el registro
*/
public int getStartOfPreviousPage() {
return Math.max(start-myPageSize, 1
); }
/**
* Obtener la posición del primer dato en la siguiente página de la base de datos
* @return el rownum correspondiente al registro
*/
public int getStartOfNextPage() {
return start avaCount
}
/**
* Obtener la primera página de cualquier página La posición del dato en la base de datos, el valor predeterminado se utiliza para el número de piezas por página
* @param pageNo page número
* @return el número de fila correspondiente al registro
* /
public static int getStartOfAnyPage(int pageNo){
return getStartOfAnyPage(pageNo, DEFAULT_PAGE_SIZE);
}
/**
* Obtiene la posición de los primeros datos en cualquier página de la base de datos
* @param pageNo número de página
* @param pageSize Los registros contenidos en cada página Número
* @return registro correspondiente al número de fila
*/
public static int getStartOfAnyPage(int pageNo, int pageSize){
int startIndex = (pageNo-1) * pageSize
1;
if (startIndex lt; 1) startIndex = 1;
//System.out.println("Número de página para iniciar el índice: " pageNo "-" startIndex);
return startIndex;
}
/**
* Obtener el número de registros contenidos en esta página
* @return El número de registros contenidos en esta página
*/
public int getSize() {
return avaCount; p>}
/**
* Obtener el número total de registros contenidos en la base de datos
* @return El número total de registros contenidos en la base de datos
* /
public int getTotalSize() {
return this.totalSize
}
/ **
* Obtener el número de página actual
* @return el número de página actual
*/
public int getCurrentPageNo() {
return this.currentPageno
}
/**
* Obtener el número total de páginas
* @return el número total de páginas
* /
public int getTotalPageCount(){
return this.totalPageCount
}
/**
*
* @param queryJSFunctionName El nombre del script JS que implementa la paginación. Este método se llamará automáticamente cuando aparezca el número de página. cambios
* @param pageNoParamName El nombre del parámetro del número de página
* @return
*/
public String getHTML(String queryJSFunctionName, String pageNoParamName){
if (getTotalPageCount()lt; 1){
return "lt; input type='hidden' name='" pageNoParamName "' valor=' 1' gt;";
}
if (queryJSFunctionName == null || queryJSFunctionName.trim().length()lt; 1) {
queryJSFunctionName = "gotoPage";
}
if (pageNoParamName == null || pageNoParamName.trim().length()lt; 1){
pageNoParamName = "pageno";
}
String gotoPage = "_" queryJSFunctionName
StringBu;
ffer html = new StringBuffer("\n");
html.append("lt;script language=\"Javascript1.2\"gt;\n")
. append("función ").append(gotoPage).append("(pageNo){ \n")
.append( " var curPage=1; \n")
.append( " try{ curPage = document.all[\"")
.append(pageNoParamName).append("\"].value; \n")
. append( " document.all[\"").append(pageNoParamName)
.append("\"].value = pageNo; \n")
.append( " ").append(queryJSFunctionName).append("(pageNo); \n")
.append( " return true; \n")
.append( " }catch (e){ \n")
// .append( " intentar{ \n")
// .append( " document.forms[0].submit() ; \n")
// .append( " }catch(e){ \n")
.append( " alert('Método de consulta aún no definido: función " )
.append(queryJSFunctionName).append("()'); \n")
.append( " document.all[\"").append(pageNoParamName)
.append("\"].value = curPage; \n")
.append( " return false; \n")
// append( " } \n")
.append( " } \n")
.append( "}")
.append( " lt ;/scriptgt; \n")
.append( "");
html.append( "lt; borde de la tabla=0 espacios entre celdas=0 relleno de celdas=0 align=centro ancho =80gt; \n")
.append( " lt; trgt; \n")
.append( " lt; td align=leftgt; lt; brgt; \ n ");
html.append( " ***" ).append( getTotalPageCount() ).append( "página")
.append( " [") . append (getStart()).append("..").append(getEnd())
.append("/").append
(this.getTotalSize()).append("] \n")
.append( " lt;/tdgt; \n")
.append( " lt;td align=rightgt; \n");
if (hasPreviousPage()){
html.append( "[lt;a href='javascript:").append(gotoPage) )
.append("() .append(getCurrentPageNo()-1)
.append( ")'gt;Página anteriorlt;/agt;] \n ") ;
}
html.append( "")
.append( " lt; seleccione nombre='")
. append(pageNoParamName).append("' onChange='javascript：")
.append(gotoPage).append("(this.value)'gt;\n"); p>. p>
Cadena seleccionada = "seleccionado";
for(int i=1; ilt; =getTotalPageCount(); i ){
if( i = = getCurrentPageNo( ) )
seleccionado = "seleccionado";
else selected = ""
html.append( " lt; valor de opción ='" ).append (i).append("' ")
.append(selected).append("gt;").append(i).append("lt;/optiongt; \n"
}
if (getCurrentPageNo()gt; getTotalPageCount()){
html.append( " lt; valor de opción='"). append(getCurrentPageNo())
.append("' selectedgt;").append(getCurrentPageNo())
.append("lt;/optiongt; \n");
}
html.append( "lt;/selectgt;page\n");
if (hasNextPage()){
html .append( " [lt; a href='javascript: ").append(gotoPage)
.append("(").append((getCurrentPageNo() 1))
.append( ")'gt; siguiente páginalt;/agt;] \n");
}
html.append( "lt;/tdgt;lt); ; /trgt;lt;/tablegt; \n");
return html.toString();
}
}
/////////////////////////////////////
//
// RowSetPage.java
// autor: evan_zhao@hotmail.com
//
//////// / ///////////////////////////
página del paquete
importar javax.sql. RowSet;
/**
* lt;pgt;Título: RowSetPagelt;/pgt;
* lt;pgt;Descripción: Un objeto de paginación que utiliza RowSet para encapsular datos lt;/pgt;
* lt;pgt; Copyright: Copyright (c) 2003lt;/pgt
* @author evan_zhao@hotmail.com
* @versión 1.0
*/
la clase pública RowSetPage extiende la página {
privada javax.sql.RowSet rs
<; p>/* **Página vacía
*/
RowSetPage final estática pública EMPTY_PAGE = new RowSetPage()
/ **
/**
p>
*Método de construcción predeterminado, crea una página vacía
*/
pública RowSetPage(){
this(null, 0, 0);
}
/**
*Construir objeto de paginación
*@param crs OracleCachedRowSet que contiene una página de datos
*@param start La posición inicial de los datos en esta página en la base de datos
*@param totalSize El número total de registros contenidos en la base de datos
*/
public RowSetPage(RowSet crs, int start, int totalSize) {
this(crs, start , totalSize, Page.DEFAULT_PAGE_SIZE);
}
/* *
*Construir objeto de paginación
*@param crs OracleCachedRowSet que contiene una página de datos
*@param start La posición inicial de esta página de datos en la base de datos
*@param totalSize El número total de registros contenidos en la base de datos
*@pageSize El número de registros que esta página puede acomodar
*/
public RowSetPage(RowSet crs, int start, int totalSize, int pageSize) {
intenta{
int avaCount=0;
if (crs!=null ) {
crs.beforeFirst();
si (crs.next()){
>crs.last();
avaCount = crs.getRow();
}
crs.beforeFirst(); }
rs = crs;
super.init(start, avaCount, totalSize, pageSize, rs
}catch(java.sql.SQLException sqle); ){
lanzar nueva RuntimeException(sqle.toString());
}
}
/**
*Obtener los datos del registro en el objeto de paginación
*/
public javax.sql.RowSet getRowSet(){
return rs; p >
}
}
////////////////////////////// // /////
//
// PagedStatement.java
// autor: evan_zhao@hotmail.com
/ /
//////////////////////////////////////
página del paquete;
importar foo.DBUtil;
importar java.math.BigDecimal
importar java.util.List
importar java.util.Iterator
importar java.util.Collections
importar java.sql.Connection
importar java.sql; .SQLException;
importar java.sql.ResultSet;
importar java.sql.Statement
importar java.sql.PreparedStatement
importar java .sql.Timestamp;
importar javax.sql.RowSet;
/**
* lt; /pgt;
* lt；pgt;Descripción: consulta los datos de la página actual de acuerdo con la declaración de la consulta y el número de páginalt;/pgt;
* lt;pgt;Copyright: Copyright ( c) 2002lt;/ pgt;
* @autor evan_zhao@hotmail.com
* @versión 1.0
*/
público clase abstracta PagedStatement {
public final static int MAX_PAGE_SIZE = Page.MAX_PAGE_SIZE
cadena protegida countSQL, querySQL
prote;
cted int pageNo, pageSize, startIndex, totalCount
javax.sql.RowSet protegido
RowSetPage protegido
lista privadaboundParams
/**
* Construya un PageStatement para consultar todos los datos
* @param sql query sql
*/
public PagedStatement(String sql){
this(sql, 1, MAX_PAGE_SIZE
}
/**
*; Construya un PageStatement para consultar los datos de la página actual
* @param sql query sql
* @param pageNo número de página
*/
public PagedStatement(String sql, int pageNo){
this(sql, pageNo, Page.DEFAULT_PAGE_SIZE
}
/**
* Construya un PageStatement para consultar los datos de la página actual y especifique el número de registros que se muestran en cada página
* @param sql query sql
* @param pageNo número de página
p>
* @param pageSize capacidad de cada página
*/
public PagedStatement(String sql, int pageNo, int pageSize ){
this.pageNo = pageNo;
this.pageSize = pageSize; p>
this.boundParams = Colecciones.synchronousdList(new java.util.LinkedList());
this.countSQL = "seleccione recuento (*) de ( " sql ") "; p>
this.querySQL = intiQuerySQL( sql, this.startIndex, pageSize
}
/**
*Generar instrucción SQL para consultar una página de datos
*@param sql declaración de consulta original
*@startIndex posición inicial de registro
*@size número de registros que se obtendrán
*/
string abstracto protegido intiQuerySQL(String sql, int startIndex, int size
/**
*Utilice el dado); objeto para establecer el valor del parámetro especificado
*@param index El primer parámetro es 1 y el
Dos son 2