So implementieren Sie die Paging-Abfragefunktion mit Java

Seitenabfrage

Seitenabfrage zeigt die riesigen Daten in der Datenbank in Segmenten an. Auf jeder Seite wird eine benutzerdefinierte Anzahl von Zeilen angezeigt, um das Benutzererlebnis zu verbessern. Das Wichtigste ist, dass alle Daten von der Serverfestplatte gelesen werden Es besteht die Gefahr eines Speicherüberlaufs

True und False Paging

False Paging: Das Prinzip besteht darin, alle Daten in den Speicher einzulesen und die Seite umzublättern, um die Daten aus dem Speicher zu lesen. Vorteile: Einfach Implementierung, hohe Leistung. Nachteile: Wenn die Daten groß sind, kann es leicht zu einem Speicherüberlauf kommen.
Echtes Paging: Fragen Sie bei jedem Seitenwechsel Daten aus der Datenbank (d. h. der Festplatte) ab. Vorteile: Es ist nicht einfach, einen Speicherüberlauf zu verursachen. Nachteile: Komplex Implementierung, relativ geringe Leistung

Paging-Effekt

Zu den allgemeinen Paging-Funktionen gehören: Startseite Vorherige Seite Nächste Seite Letzte Seite Wie viele Datenzeilen gibt es insgesamt? Wie viele Daten pro Seite müssen wir abfragen und in ein Objekt kapseln, was die Idee der Kapselung verkörpert und viel komplexen Code einspart? für die Paginierung

Parameter, die vom Benutzer übergeben werden müssen:

currentPage: aktuelle Seite, zu welcher Seite gesprungen werden soll, beim ersten Besuch erstellen wir ein Objekt, der Standardwert ist 1

pageSize: Wie viele Datenzeilen Zum ersten Mal geben wir auch einen Standardwert an, z. B. 10.

Die Daten, die im Paging angezeigt werden müssen

1 Die Produktinformationen der aktuellen Seite

2. Welche Seite ist die Startseite? 4. Welche Seite ist die nächste Seite? 5. Wie viele Seiten sind insgesamt vorhanden? 7. Die aktuelle Seite ist Welche Seite

8. Wie viele Informationen werden auf jeder Seite angezeigt

Die Quelle der Daten, die im Paging angezeigt werden müssen

stammt aus dem Benutzer-Upload : aktuelle Seite, wie viele Daten werden auf jeder Seite angezeigt.
stammt aus der Datenbankabfrage: Gesamtzahl der Daten. Die Produktinformationen, die auf jeder Seite angezeigt werden müssen, werden auf der Grundlage der oben genannten bekannten Informationen berechnet: Gesamtzahl der Seiten , vorherige Seite, nächste Seite


Schreiben Sie die aus der Datenbank abgefragte SQL-Anweisung

Die erste SQL-Abfrage in der Datenbank. Wie viele Daten dürfen nach COUNT vorhanden sein?

SELECT COUNT(*) FROM 表名

Die zweite SQL-Abfrage Seite basierend auf den übergebenen Parametern und der Ergebnismenge, wie viele Daten auf einer Seite vorhanden sind

# 第一个 ?：从哪一个索引的数据开始查询(默认从 0 开始)
# 第二个 ?：查询多少条数据
SELECT * FROM 表名 LIMIT ?, ?

Analysieren Sie als Nächstes die beiden in der zweiten SQL? , und jede Seite ist in 5 Datenteile unterteilt:
Fragen Sie die erste Datenseite ab: SELECT * FROM product LIMIT 0, 5
Fragen Sie die zweite Datenseite ab: SELECT * FROM product LIMIT 5, 5

Fragen Sie die Daten ab Dritte Seite: SELECT * FROM product LIMIT 10, 5

Fragen Sie die Daten auf der vierten Seite ab: SELECT * FROM product LIMIT 15, 5Entdecken Sie, indem Sie nach dem Muster suchen: Der erste?-Wert kommt von (currentPage - 1) * pageSize; Der zweite Wert stammt von pageSize, das heißt, sie stammen alle aus den vom Benutzer übergebenen Paging-Parametern.

Gesamtzahl der Seiten, vorherige Seite und nächste Seite

// 优先计算总页数
int totalPage = rows % pageSize == 0 ? rows / pageSize : rows / pageSize + 1;
//上一页等于当前页-1,但不能超过1页界限
int prevPage = currentPage - 1 >= 1 ? currentPage - 1 : 1;
//下一页等于当前页+1,但不能超过总页数界限
int nextPage = currentPage + 1 <= totalPage ? currentPage + 1 : totalPage;

Implementierung der Seitenabfrage


Zugriffsprozess:

Kapseln Sie die Daten, die angezeigt werden müssen.

Wenn die Daten nicht gekapselt sind Alle Daten müssen im Bereich gespeichert werden. Die Daten sind zu verstreut und für eine einheitliche Verwaltung unpraktisch.

/**
* 封装结果数据（某一页的数据）
*/
@Getter
public class PageResult<T> {
    // 两个用户的输入
    private int currentPage; // 当前页码
    private int pageSize; // 每页显示的条数
    // 两条 SQL 语句执行的结果
    private int totalCount; // 总条数
    private List<T> data; // 当前页结果集数据
    // 三个程序计算的数据
    private int prevPage; // 上一页页码
    private int nextPage; // 下一页页码
    private int totalPage; // 总页数/末页页码
    // 分页数据通过下面构造期封装好
    public PageResult(int currentPage, int pageSize, int totalCount, List<T>
    data) {
        this.currentPage = currentPage;
        this.pageSize = pageSize;
        this.totalCount = totalCount;
        this.data = data;
        // 计算三个数据
        this.totalPage = totalCount % pageSize == 0 ? totalCount / pageSize :
        totalCount / pageSize + 1;
        this.prevPage = currentPage - 1 >= 1 ? currentPage - 1 : 1;
        this.nextPage = currentPage + 1 <= this.totalPage ? currentPage + 1 :
        this.totalPage;
    }
}

Persistenzschicht-DAO

Die von Mybatis bereitgestellte Operationsmethode kann nur einen Parameter übergeben, um die SQL-Aufgabe auszuführen. und wir fragen jetzt die Daten einer bestimmten Seite ab. Wir müssen die beiden Parameter kennen, um welche Seite es sich handelt und wie viele Daten pro Seite vorhanden sind. Daher müssen wir diese beiden Parameter in einem Objekt kapseln. Schreiben Sie eine Klasse (mit dem Namen). Abfrageobjektklasse), um diese Abfragedaten zu kapseln

@Setter
@Getter
/**
* 封装分页查询需要的两个请求传入的分页参数
*/
public class QueryObject {
    private int currentPage = 1; // 当前页码，要跳转到哪一页的页码（需要给默认值）
    private int pageSize = 3; // 每页显示条数（需要给默认值）
}

Dann schreiben Sie die Persistenzschicht-DAO-Schnittstelle und die Implementierungsklasse

//DAO接口提供两个根据查询对象的查询方法
int queryForCount();
List<Product> queryForList(QueryObject qo);
//DAO实现类
@Override
//查询数据库总数据条数
public int queryForCount() {
    SqlSession session = MyBatisUtil.getSession();
    int totalCount =
    session.selectOne("cn.xxx.mapper.ProductMapper.queryForCount");
    session.close();
    return totalCount;
}
@Override
//查询某一页的结果集
public List<Product> queryForList(QueryObject qo) {
    SqlSession session = MyBatisUtil.getSession();
    List<Product> products =
    session.selectList("cn.xxx.mapper.ProductMapper.queryForList",qo);
    session.close();
    return products;
}

Ändern Sie productMapper.xml

<select id="queryForCount" resultType="int">
SELECT COUNT(*) FROM product
</select>
<select id="queryForList" resultType="cn.xxx.domain.Product">
SELECT * FROM product LIMIT #{start}, #{pageSize}
</select>

Ändern Sie QueryObject.java

Fügen Sie die getStart-Methode zu dieser Klasse hinzu und geben Sie die Zeile zurück Von hier aus muss die Größe jeder Seite basierend auf der aktuellen Seite aus der Datenbank angezeigt werden Implementierung der Front-End-Paging-Funktion

1 Die Business-Layer-Komponenten müssen zuerst abgeschlossen sein, um sicherzustellen, dass der Backend-Test bestanden wurde.

2. Folgen Sie der MVC-Denkweise.

3. Der Browser sendet die Paging-Anforderungsparameter (zu welcher Seite er gehen soll/wie viele Daten pro Seite), empfängt diese Parameter im Servlet und kapselt sie
4. Gehen Sie zum QueryObject-Objekt und rufen Sie die Paging-Abfragemethode auf (Abfrage) im Dienst.

5. Geben Sie das erhaltene Paging-Abfrageergebnisobjekt (PageResult) im Anforderungsbereich frei, springen Sie zu JSP und zeigen Sie es an.

6. Ändern Sie die JSP-Seite und schreiben Sie die Informationen zur Paging-Leiste (die Informationen in der Paging-Leiste stammen vom PageResult-Objekt).

ProductServlet.java ändern und jsp anzeigen

1. Rufen Sie die Seitenanforderungsparameter ab, stellen Sie fest, dass es sich um eine Abfrageoperation handelt, rufen Sie die Abfragemethode auf und rufen Sie die Paging-Parameter ab.

Kapseln Sie die Parameter in ein Abfrageobjekt QueryObject 3. Rufen Sie die Business-Layer-Methode auf, um eine bestimmte Datenseite abzufragen

4. Speichern Sie die Abfrageergebnisse im Bereich jsp6. Nehmen Sie die Ergebnisse aus dem Bereich in jsp

@Setter
@Getter
/**
* 封装分页查询需要的两个请求传入的分页参数
*/
public class QueryObject {
    private int currentPage = 1; // 当前页码，要跳转到哪一页的页码（需要给默认值）
    private int pageSize = 3; // 每页显示条数（需要给默认值）
    // 用于 Limit 子句第一个 ? 取值
    public int getStart(){
        return (currentPage - 1) * pageSize;
    }
}

Ändern Sie die JSP-Datei und verwenden Sie JSTL+EL, um Daten im Gültigkeitsbereich abzurufen

//IProductService接口
public interface IProductService {
    /**
    * 完成查询某一页的业务逻辑功能
    */
    PageResult<Product> query(QueryObject qo);
}
//Service实现类
public class ProductServiceImpl implements IProductService {
    private IProductDAO productDAO = new ProductDAOImpl();
    @Override
    public PageResult<Product> query(QueryObject qo) {
        // 调用 DAO 查询数据数量
        int totalCount = productDAO.queryForCount();
        // 为了性能加入判断，若查询的数据数量为 0，说明没有数据，返回返回空集合，即集合中没有
        元素
        if(totalCount == 0){
            return new PageResult(qo.getCurrentPage(), qo.getPageSize(),
            totalCount, Collections.emptyList());
        }
        // 执行到这里代表有数据，查询当前页的结果数据
        List<Product> products = productDAO.queryForList(qo);
        return new PageResult(qo.getCurrentPage(), qo.getPageSize(), totalCount,
        products);
    }
}

FAQ

Wenn der Umblättervorgang erfolgreich ist und Sie nach ein paar Seiten nicht umblättern können, können Sie Tomcat nur durch einen Neustart umblättern. Problem: Das SqlSession-Objekt ist in DAO nicht geschlossen

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Paging-Abfragefunktion mit Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!