Le problème de pagination est un problème très courant que presque tous les développeurs rencontreront. Je ne discuterai pas spécifiquement ici de la manière de procéder à la pagination, mais j'expliquerai le principe de la pagination en mode Web. La première consiste à interroger pour obtenir un ensemble de résultats (affichés comme les résultats obtenus en interrogeant la base de données). S'il y a de nombreux résultats, nous n'afficherons généralement pas toutes les données en même temps, nous utiliserons alors la pagination pour afficher certaines données (telles que). comme 20 articles). En raison de la nature apatride du HTTP, chaque soumission est traitée comme une nouvelle requête. Même si la page est modifiée, le dernier résultat n'a aucun impact sur le suivant.
Voici trois façons d’implémenter la pagination. Je ne sais pas s’il y en a d’autres !
1. Obtenez toutes les données des résultats de la requête à chaque fois, puis affichez les enregistrements spécifiés en fonction du numéro de page.
2. Obtenez une seule page de données basée sur la page, puis affichez cette page. Ici, vous devez construire une instruction SQL.
3. Prendre un certain nombre de pages de données est un compromis entre les deux précédents.
Ce qu'il convient également de noter ici, c'est si les données sont placées dans la requête ou dans la session, ce qui sera discuté une par une ici.
1. Généralement, il ne sera pas placé dans la session car il occupera beaucoup de mémoire, il doit donc être placé dans la requête.
Avantages : La mise en œuvre est relativement simple et la vitesse de requête est relativement rapide.
Inconvénients : Il utilise plus de mémoire et transmet beaucoup de données sur le réseau.
Cette méthode est plus adaptée aux requêtes contenant des quantités de données relativement faibles. Certaines personnes ici mettent les données dans la session afin qu'il n'y ait pas besoin de réinterroger lors du changement de page. Cependant, cela est extrêmement mauvais et il est fortement déconseillé de l'utiliser de cette manière.
2. Il ne sera certainement pas placé dans la session, car cela n'a aucun sens de le mettre dans la session.
Avantages : prend moins de mémoire.
Inconvénients : C'est plus gênant. Vous devez d'abord obtenir le nombre total de résultats de requête, car vous devez connaître le nombre d'enregistrements pour savoir combien de pages il y a. De plus, il est nécessaire de construire une instruction de requête de pagination, qui est différente selon les bases de données.
3. Cette situation doit être placée dans la session, sinon pourquoi devrais-je récupérer plusieurs pages ? Cette implémentation vise à réduire le nombre de requêtes dans la base de données. Par exemple, si je sauvegarde les enregistrements 1 à 10, alors lors du changement de page, si entre 1 et. 10 peuvent être obtenus directement à partir de la séance. Si je passe à la page 11, je peux réinitialiser le cache à 11
20 pages de données (soit 5 à 15 pages de données), dans ce cas, une seule opération de requête en base de données est nécessaire pour 10 modifications.
Avantages : Il occupe relativement peu de mémoire et améliore la vitesse moyenne des requêtes.
Inconvénients : C'est plus complexe à mettre en œuvre, des données sales peuvent exister et vous devez définir vous-même une collection de cache. Si la quantité de données interrogées est relativement importante, vous pouvez envisager d'utiliser cette méthode.
La conception suivante n'obtient qu'une seule page de données à chaque fois, et le nombre total de requêtes doit être réinitialisé à chaque fois. Comment l'implémenter vous-même ? Il s'agit d'une implémentation de pagination relativement courante.
Concevez une interface ici :
package treeroot.util;import java.util.List;/*** Cette interface est utilisée pour implémenter la fonction de pagination. Notez qu'aucune fonction de modification n'est fournie ici. * @author treerot* @version 1.0* @since 2004-9-30*/public interface Pageable{ /** * Obtenir les résultats des données* @return */ public List getResult( /** * Obtenir le nombre total de requêtes) * @return */ public int getCount(); /** * Récupère le nombre d'enregistrements par page* @return */ public int getPageSize(); /** * Récupère le numéro de la page actuelle* @return */ public int getCurrentPage(); /** * Obtenez le nombre total de pages* @return */ public int getPages(); /** * Le nombre d'enregistrements par défaut affichés sur chaque page*/ public final static int DEFAULT_PAGESIZE=20;} Cette interface est très simple. Elle comprend une liste de résultats et quelques informations nécessaires à la pagination. Notez ici quelques points :
1. L'implémentation de cette interface représente une certaine page de données dans une certaine requête, qui n'a rien à voir avec la dernière requête.
2. L'implémentation de cette interface doit être en lecture seule, ce qui signifie qu'elle ne peut pas être modifiée.
3. La méthode getPages() est redondante, mais cette méthode est toujours fournie ici.
Une implémentation abstraite est donnée ci-dessous :
package treeroot.util;import java.util.List;/*** @author treerot* @version 1.0* @depuis 2004-9-30*/public abstract class AbstractPage implémente Pageable{ private int currentPage ; private int pageSize ; pages ; protected int count ; protected List result ; /** * Spécifiez la page actuelle* @param currentPage * @throws PageException */ public AbstractPage(int currentPage){ this(currentPage,Pageable.DEFAULT_PAGESIZE); } /** * Spécifiez la page actuelle et la taille de la page* @param currentPage * @param pageSize * @throws PageException */ public AbstractPage(int currentPage,int pageSize) { this.currentPage=currentPage); ; this.pageSize=pageSize; } protected void checkPage(int currentPage) lance PageException{ if((currentPage<1)||(currentPage>this.getPages())) throw new PageException("Page hors plage : le nombre total de pages est "+this.getPages()+", la page actuelle est " +currentPage); } /** * Cette méthode est remplacée par la sous-classe pour l'initialisation, c'est-à-dire pour calculer la valeur de comptage et le résultat, et est appelée dans le constructeur de la sous-classe. */ abstract protected void init() throws PageException ; public List getResult() { return result; } public int getCount() { return count; } public int getPageSize() { return pageSize ; } public int getPages() { if(pages==0) this.pages=(count+pageSize-1)/pageSize return; pages ;}}Cette classe abstraite implémente toutes les méthodes de l'interface, mais définit une méthode abstraite init(), qui doit être implémentée dans les sous-classes. L'interface et la classe abstraite ci-dessus semblent relativement simples. Vous pouvez avoir l'impression qu'elles ne font rien en termes d'implémentation, mais elles peuvent apporter une grande aide au développement. Nous pouvons hériter de cette classe abstraite en fonction de nos propres besoins, et les données peuvent être obtenues de différentes manières, par exemple directement via une liste, ou via JDBC, Hibernate, etc., mais nous devons tous encapsuler les résultats dans une liste, via Hibernate Cela semble particulièrement pratique.
PageException est une exception personnalisée
package treeroot.util /*** @author treeroot* @version 1.0* @depuis 2004-9-30*/public class PageException extends Exception{ public PageException(){ super( } public PageException(String message){ super( message); }}