O problema de paginação é um problema muito comum que quase todos os desenvolvedores encontrarão. Não discutirei especificamente como fazer a paginação aqui, mas explicarei o princípio da paginação no modo Web. A primeira é consultar para obter um conjunto de resultados (mostrado como os resultados obtidos na consulta ao banco de dados. Se houver muitos resultados, geralmente não exibiremos todos os dados de uma vez, então usaremos a paginação para exibir determinados dados (como). como 20 itens). Devido à natureza sem estado do HTTP, cada envio é tratado como uma nova solicitação. Mesmo que a página seja alterada, o último resultado não terá impacto no próximo.
Aqui estão três maneiras de implementar a paginação, não sei se existem outras!
1. Obtenha todos os dados dos resultados da consulta a cada vez e exiba os registros especificados de acordo com o número da página.
2. Obtenha apenas uma página de dados com base na página e, em seguida, exiba esta página. Aqui você precisa construir uma instrução SQL.
3. Tomar um certo número de páginas de dados é um compromisso entre os dois anteriores.
O que também deve ser observado aqui é se os dados são colocados na solicitação ou na sessão, que serão discutidos um a um aqui.
1. Geralmente não será colocado na sessão porque ocupará muita memória, por isso deve ser colocado na solicitação.
Vantagens: A implementação é relativamente simples e a velocidade de consulta é relativamente rápida.
Desvantagens: Ocupa mais memória e transmite muitos dados pela rede.
Este método é mais adequado para consultas com quantidades relativamente pequenas de dados. Algumas pessoas aqui colocam os dados na sessão para que não haja necessidade de nova consulta ao mudar de página. Porém, isso é extremamente ruim e é fortemente recomendado não ser usado desta forma.
2. Definitivamente não será colocado na sessão, pois não faz sentido colocá-lo na sessão.
Vantagens: ocupa menos memória.
Desvantagens: É mais problemático primeiro você deve obter o número total de resultados da consulta, porque você precisa saber quantos registros existem para saber quantas páginas existem. Além disso, é necessário construir uma instrução de consulta de paginação, que é diferente para bancos de dados diferentes.
3. Esta situação deve ser colocada na sessão, caso contrário, por que eu buscaria várias páginas? Essa implementação serve para reduzir o número de consultas ao banco de dados. Por exemplo, se eu salvar os registros de 1 a 10, então se eu alterar a página, entre 1. e 10 podem ser obtidos diretamente na sessão. Se eu mudar para a página 11, posso redefinir o cache para 11
20 páginas de dados (ou 5 a 15 páginas de dados), neste caso, é necessária apenas uma operação de consulta ao banco de dados para 10 alterações.
Vantagens: Ocupa relativamente pouca memória e melhora a velocidade média de consulta.
Desvantagens: É mais complexo de implementar, podem existir dados sujos e você mesmo precisa definir uma coleção de cache. Se a quantidade de dados consultados for relativamente grande, considere usar este método.
O design a seguir obtém apenas uma página de dados por vez, e o número total de consultas deve ser redefinido a cada vez. Como implementar você mesmo? Esta é uma implementação de paginação relativamente comum.
Projete uma interface aqui:
package treeroot.util;import java.util.List;/*** Esta interface é usada para implementar a função de paginação. Observe que nenhuma função de modificação é fornecida aqui. * @author treerot* @versão 1.0* @desde 2004-9-30*/public interface Pageable{ /** * Obter resultados de dados* @return */ public List getResult(); * @return */ public int getCount(); /** * Obtém o número de registros por página* @return */ public int getPageSize(); int getCurrentPage(); /** * Obtém o número total de páginas* @return */ public int getPages() /** * O número padrão de registros exibidos em cada página*/ public final static int DEFAULT_PAGESIZE=20;} Esta interface é muito simples. Inclui uma lista de resultados e algumas informações necessárias para paginação.
1. A implementação desta interface representa uma determinada página de dados em uma determinada consulta, que nada tem a ver com a última consulta.
2. A implementação desta interface deve ser somente leitura, o que significa que não pode ser modificada.
3. O método getPages() é redundante, mas ainda é fornecido aqui.
Uma implementação abstrata é fornecida abaixo:
package treeroot.util;import java.util.List;/*** @author treerot* @versão 1.0* @desde 30/09/2004*/public abstract class AbstractPage implements Pageable{ private int currentPage; páginas; protected int count; protected List result /** * Especifique a página atual* @param currentPage * @throws PageException */ public AbstractPage(int currentPage){ this(currentPage,Pageable.DEFAULT_PAGESIZE); /** * Especifique a página atual e o tamanho da página* @param currentPage * @param pageSize * @throws PageException */ public AbstractPage(int currentPage,int pageSize) { this.currentPage=currentPage ; this.pageSize=pageSize; } protegido void checkPage(int currentPage) lança PageException{ if((currentPage<1)||(currentPage>this.getPages())) throw new PageException("Página fora do intervalo: o número total de páginas é "+this.getPages()+", a página atual é " +currentPage); } /** * Este método é substituído pela subclasse para inicialização, ou seja, para calcular o valor e o resultado da contagem, e é chamado no construtor da subclasse. */ abstract protected void init() lança PageException; public List getResult() { return result; public int getCount() { return count; } public int getPages() { if(pages==0) this.pages=(count+pageSize-1)/pageSize return; páginas; }}Esta classe abstrata implementa todos os métodos da interface, mas define um método abstrato init(), que deve ser implementado em subclasses. A interface e a classe abstrata acima parecem relativamente simples. Você pode sentir que elas não fizeram nada. Na verdade, elas não fizeram nada em termos de implementação, mas podem trazer grande ajuda para o desenvolvimento. Podemos herdar essa classe abstrata de acordo com nossas próprias necessidades, e os dados podem ser obtidos de várias maneiras, como diretamente por meio de uma Lista, ou por meio de JDBC, Hibernate, etc., mas todos precisamos encapsular os resultados em uma Lista, através do Hibernate Parece particularmente conveniente.
PageException é uma exceção personalizada
package treeroot.util /*** @author treeroot* @versão 1.0* @desde 30/09/2004*/public class PageException estende Exception{ public PageException(){ super() } public PageException(String message){ super( mensagem); }}