Django 自定义分页类

分页类代码：

class Page(object):
    ''''''
    自定义分页类
    可以实现Django ORM数据的的分页展示
    输出HTML代码：

    使用说明：
    from utils import mypage
        page_obj = mypage.Page(total_num, current_page, ''publisher_list'')
        publisher_list = data[page_obj.data_start:page_obj.data_end]
        page_html = page_obj.page_html()

        为了显示效果，show_page_num最好使用奇数
    ''''''

    def __init__(self, total_num, current_page, url_prefix, per_page=10, show_page_num=9):
        ''''''

        :param total_num: 数据总条数
        :param current_page: 当前访问的页码
        :param url_prefix: 分页代码里a标签的前缀
        :param per_page: 每一页显示多少数据
        :param show_page_num: 页面上最多显示多少个页码


        ''''''
        self.total_num = total_num
        self.url_prefix = url_prefix
        self.per_page = per_page
        self.show_page_num = show_page_num
        # 根据传入的值计算当前页码左右放置多少个页码
        self.half_show_page_num = self.show_page_num // 2
        # 计算当前数据总共需要多少页码
        total_page, more = divmod(self.total_num, self.per_page)
        # 如果有余数就把页码加1
        if more:
            total_page += 1
        self.total_page = total_page
        # 数据有效性校验
        try:
            current_page = int(current_page)
        except Exception as e:
            current_page = 1
        # 如果当前页码数大于总页码数，默认展示最后一页数据
        if current_page > self.total_page:
            current_page = self.total_page
        # 如果当前页码小于1，默认展示第一页数据
        if current_page < 1:
            current_page = 1
        self.current_page = current_page
        # 计算页面上需要展示的页码范围
        # 页码过小处理
        if self.current_page - self.half_show_page_num <= 1:
            page_start = 1
            page_end = show_page_num
        # 页码过大处理
        elif self.current_page + self.half_show_page_num >= self.total_page:
            page_end = self.total_page
            page_start = self.total_page - self.show_page_num + 1
        # 未超过正常范围
        else:
            page_start = self.current_page - self.half_show_page_num
            page_end = self.current_page + self.half_show_page_num

        # 计算得到的最终页码数
        self.page_start = page_start
        self.page_end = page_end
        # 如果计算得到的页码数比总共需要展示页码数多，则把页码结束指定为总页码数
        if self.page_end > self.total_page:
            self.page_end = self.total_page

    @property
    def data_start(self):
        ''''''

        :return: 返回当前页面应该从哪里开始切数据
        ''''''
        return (self.current_page - 1) * self.per_page

    @property
    def data_end(self):
        ''''''

        :return: 返回当前页面从哪里结束数据
        ''''''
        return self.current_page * self.per_page

    def page_html(self):
        li_list = []
        # 添加前面的nav和ul标签
        li_list.append("""
        <nav aria-label="Page navigation">
        <ul>
        """)
        # 添加首页
        li_list.append(''<li><a href="/{}/?page=1">首页</a></li>''.format(self.url_prefix))
        # 添加上一页
        if self.current_page <= 1:  # 没有上一页
            prev_html = ''<li><a aria-label="Previous"><span aria-hidden="true">&laquo;</span></a></li>''
        else:
            prev_html = ''<li><a href="/{}/?page={}" aria-label="Previous"><span aria-hidden="true">&laquo;</span></a></li>''.format(
                self.url_prefix,
                self.current_page - 1)
        li_list.append(prev_html)
        # 循环添加内部所有的页码
        for i in range(self.page_start, self.page_end + 1):
            if i == self.current_page:
                tmp = ''<li><a href="/{0}/?page={1}">{1}</a></li>''.format(self.url_prefix, i)
            else:
                tmp = ''<li><a href="/{0}/?page={1}">{1}</a></li>''.format(self.url_prefix, i)
            li_list.append(tmp)
        # 添加下一页
        if self.current_page >= self.total_page:  # 表示没有下一页
            next_html = ''<li><a aria-label="Previous"><span aria-hidden="true">&raquo;</span></a></li>''
        else:
            next_html = ''<li><a href="/{}/?page={}" aria-label="Previous"><span aria-hidden="true">&raquo;</span></a></li>''.format(
                self.url_prefix, self.current_page + 1)
        li_list.append(next_html)
        # 添加尾页
        li_list.append(''<li><a href="/{}/?page={}">尾页</a></li>''.format(self.url_prefix, self.total_page))
        # 添加结尾nav和ul标签
        li_list.append("""
        </ul>
        </nav>
        """)
        # 将生成的标签拼接成一个大字符串
        page_html = ''''.join(li_list)
        return page_html


导入文件后调用代码：

# 获取分页所需数据
total_num = data.count() # 获取数据总计条数
current_page = request.GET.get(''page'') # 获取当前页页码
url_prefix = request.path_info.strip(''/'') # 获取a标签所需参数

# 调用分页类
# 调用类传入参数生成实例
page_obj = mypage.Page(total_num, current_page, url_prefix, per_page=1)
# 按照分页所需数据对总数据进行分割获取当前页面所需展示的数据
data = data[page_obj.data_start:page_obj.data_end]
# 获取HTML代码
page_html = page_obj.page_html()

java自定义分页工具（自定义分页工具类）

1. 分页的工具类一直都不会写，没有理解里面几个属性的意思，趁这个时间看了一下别人写的分页工具类，然后自己也模仿写了一个分页的工具类，虽然有很多已经封装好了的分页工具，pagehelp什么的，但是如果不能用那个呢，还是要自己动手写一个分页工具类的。
   这里是原博主的链接
2. 虽然现在有很多好用的框架，对分页进行支持，很简单的就把分页的效果做出来，但是如果手动实现分页效果又如何呢？
3. （1）分页的思路
   首先我们得知道写分页代码时的思路，保持思路清晰，有步骤的进行，才能行云如水。先来看看分页的效果

   

   
   这就是一个分页导航，其中能得到的数据有

totalRecord：总共员工数，数据库中总的记录数，这里有55条

totalPage：总页数，11页

pageSize：每页显示的记录数，这里可以看到每页显示5条

pageNum：当前页为第几页，比如图中就为第9页，因为9是没有超链接的，

start:总共能显示5页，让用户进行点击，7为起始页

end：11为能显示的尾页，也就是，如果用户点击第8页，那么start就为6，end就为10，每次都只有5页共点击查询。

每次能够得到对应页数所需要的5条数据，等等这些数据都要在jsp中显示出来，也就是说，每次都要从后台拿那么多数据过来进行显示，所以我们就想办法把这些数据封装在一个javabean当中，每次后台都将查询到的数据放入javabean对象中，我们只需要将该对象存入request作用域，然后在jsp页面中从域中获取需要的数据即可。
（2）创建PageBean存放数据
总共需要8个属性pageNum、pageSize、totalRecord、totalPage、startIndex、list、start、end，

pageNum、pageSize、totalRecord：通过构造方法就能得到。pageNum请求页面提交过来的参数，pageSize是自己设置的，totalRecord是查询数据库得到的
totalPage、startIndex、start、end是通过内部算法得出，
list需要通过查询数据库在通过set方式得到。

注意：该类使用泛型是为了不仅仅在这个项目中使用，在别的项目中也同样可以使用
PageBean.java 分页工具类

package com.onlinesearch.utils;
import java.util.List;

/**
 * 尝试写公共的分页工具
 * @author Mr.zhou
 */
public class PageBean<T> {

    // 已知数据
    private int pageNum; // 当前页的数据
    private int pageSize; // 每页显示的数据
    private int totalRecord; // 总的记录条数，通过查询数据得到

    // 需要计算的数据
    private int totalPage; // 总页数，通过pageSzie/totalRecord得到

    // 开始索引，也就是我们在数据库中要从第几行数据开始拿，有了startIndex和pageSize
    // 就知道了limit语句的两个数据，就能拿到每页能显示的数据了
    private int startIndex;

    // 将每页需要显示的数据放在list集合中
    private List<T> list;

    //分页显示的页数，比如页面显示的是1，2，3，4，5页，start就为1，end就为5，这个也是需要算过来的
    private int start;
    private int end;

    // 通过pageNum,pageSize,totalRecord可以获取totalRecord和startIndex
    // 通过构造方法初始化这些属性
    public PageBean(int pageNum, int pageSize, int totalRecord) {
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.totalRecord = totalRecord;

        // 计算totalPage总页数
        if (totalRecord/pageSize == 0) {
            // 如果整除了，正好每页显示pageSize条数据，
            this.totalPage = totalRecord/pageSize;
        }else {
            // 如果不整除，需要另外添加一页来显示多余的数据
            this.totalPage = totalRecord/pageSize + 1;
        }

        //计算开始索引 公式就是（第几页-1）* 每页需要显示的数据
        this.startIndex = (pageNum-1)*pageSize;

        this.start = 1;
        this.end = 5;

        // 显示页数的算法
        // 显示5页
        // 如果总页数小于5条
        if (totalPage <= 5) {
            // 那么end就是总页数的值了
            this.end = this.totalPage;
        }else {
            // 如果总页数大于5条,那么就要根据当前页来判断start和end为多少了
            this.start = pageNum -2;
            this.end = pageNum + 2;
            if (start < 0) {
                // 如果当前页是第一页，或者第二页，就不按照这个规则了
                this.start = 1;
                this.end = 5;
            }
            if (end > this.totalPage) {
                // 如果当前页是倒数第二页或者倒数第一页，同样页不按照这个规则了
                this.end = totalPage;
                this.start = end - 5;
            }
        }
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getTotalRecord() {
        return totalRecord;
    }

    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public int getStartIndex() {
        return startIndex;
    }

    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getEnd() {
        return end;
    }

    public void setEnd(int end) {
        this.end = end;
    }
}

User.java 实体类

package com.onlinesearch.pojo;

import lombok.Data;

/**
 * @author Mr.zhou
 */
@Data
public class User {
    private String id;
    private String name;
    private String age;
    private String sex;
    private String idCard;
}

先写一个mapper接口
UserMapper.java

package com.onlinesearch.mapper;

import com.onlinesearch.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

@Mapper
public interface UserMapper {

    /**
     * 获取全部用户
     * @return
     */
    List<User> findAllUser();

    /**
     * 分页获取用户数据
     * @param startIndex
     * @param pageSize
     * @return
     */
    List<User> findAll(@Param("startIndex") int startIndex, @Param("pageSize") int pageSize);
}

UserMapper.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.onlinesearch.mapper.UserMapper">

        <resultMap id="UserResultEntity" type="com.onlinesearch.pojo.User">
            <result column="id" property="id"/>
            <result column="name" property="name"/>
            <result column="age" property="age"/>
            <result column="sex" property="sex"/>
            <result column="idcard" property="idCard"/>
        </resultMap>

    <select id="findAll"  resultMap="UserResultEntity">
        select id,name,age,sex,idcard from tb_user limit #{startIndex},#{pageSize}
    </select>

    <select id="findAllUser" resultType="com.onlinesearch.pojo.User">
        select id,name,age,sex,idcard from tb_user
    </select>
</mapper>

UserService.java 接口

package com.onlinesearch.service;


import com.onlinesearch.utils.PageBean;
import com.onlinesearch.pojo.User;


/**
 * @author Mr.zhou
 */
public interface UserService {

    /**
     * 获取每页的用户数据
     * @param pageNum
     * @param pageSize
     * @return
     */
    PageBean<User> findAllUserWithPage(int pageNum, int pageSize);
}

UserServiceImpl.java 实现类

package com.onlinesearch.service.impl;

import com.onlinesearch.utils.PageBean;
import com.onlinesearch.service.UserService;
import com.onlinesearch.pojo.User;
import com.onlinesearch.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


/**
 * @author Mr.zhou
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired(required = false)
    private UserMapper userMapper;

    @Override
    public PageBean<User> findAllUserWithPage(int pageNum,int pageSize) {
        // 在这里就要将PageBean里面的数据创建好（初始化好）然后将对象返回回去
        // 先从数据库中获取所有用户的全部数量，获得totalRecord
        List<User> allUser = userMapper.findAllUser();
        int totalRecord = allUser.size();
        // 有了三个初始工具，就能够创建PageBean对象了
        PageBean<User> pageBean = new PageBean<>(pageNum,pageSize,totalRecord);
        // 获取PageBean对象中的startIndex （从数据库中的第几行开始拿）
        int startIndex = pageBean.getStartIndex();
        // 有了startIndex和pageSize，就可以拿到每页的数据了
        pageBean.setList(userMapper.findAll(startIndex,pageSize));
        return pageBean;
    }
}

UserController.java 控制层

package com.onlinesearch.controller;

import com.onlinesearch.utils.PageBean;
import com.onlinesearch.service.UserService;
import com.onlinesearch.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@ResponseBody
@RequestMapping("test")
public class UserController {

    @Autowired
    private UserService userService;
    @RequestMapping("/test")
    public PageBean<User> test() {
        // 第一个参数是前端传过来的，表示第几页，第二个参数表示每页显示几条数据也可以从前端传过来
        // 只需要三个参数就可以实现分页了，总数（后端获得），第几页（前端传过来），每页的数量（前端传过来，也可以写死）
        PageBean<User> allUserWithPage = userService.findAllUserWithPage(2,5);
        // 可以返回json，也可以返回视图，将数据放到request中都行
        return allUserWithPage;
    }
}

最后结果：

jsp自定义分页标签page

日常工作项目里，分页是十分常见的，网上也有大把的分页插件，性能和美观程度都比较不错，但是有时候并不一定能满足我们的需求，因为大部分的分页插件都是在客户端分页，有的甚至需要你一次性查询出所有的数据放入内存，在内存进行分页，而且分也时，只是单纯分页只接受页码，并不能传入本页的某些参数到另一个页面做重新查询的条件，进而重新分页。

             根据jsp自定义分页标签的特性，我们可以定制自己的分页标签，更加方便开发中的使用，关于jsp的自定义标签，上篇已有详细的介绍说明，http://jackjobs.iteye.com/admin/blogs/1827385

             

              该页最下面的 分页栏，即是自定义的jsp的标签，我这里给的名字是<page:page pager="${requestScope.pb}" />，即只要引入它即可出现该分页栏，由于为了方便，样式可能不太好看，这个大家可以自己去调节。

                   下面我们开始实现这个page标签，首先新建一个web项目，并引入struts必要地几个jar包。新建一个包，取名为com.page.util，将page的三个实现类放在下面，分别是Pager.java，PagerHelp.java，PageTag.java，它们的实现分别如下：

Pager.java：

PagerHelp.java：

PageTag.java：

                          实现类的完成即是为了实现标签的功能，这里我们在WEB-INF下新建文件夹mytag，新建文件pagetag.tld，在这个文件里对你想要声明的自定义标签，并制定它的实现类，代码如下：

                    至此，我们的自定义page分页标签业已全部实现了，下面我们就来模拟使用下，新建com.action.TestAction.java，代码如下：

                    这个类模拟了数十条的分页数据，下面新建两个jsp页面，代码分页如下：

index.jsp：

test.jsp：

 这个页面会使用到page标签，及在文件头引入所需的taglib，并引入Pager.js，该js的代码如下：

                至此，在web.xml和struts.xml中做好各项配置，启动服务器，键入localhost：8080/mytag/index.jsp，点击"Test Go~~"链接，即出现截图效果，如有报错，请根据错误检查各项配置。

               如果需要在分页时，在页面间传递参数，如以上action代码中模拟的a和b的话，即全部用stringbuffer拼接就可以了，我们右键test.jsp效果页面时，可以看到传递的参数url，如图：

关于php自定义分页类和php实现分页的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Cakephp 3 自定义分页、Django 自定义分页类、java自定义分页工具（自定义分页工具类）、jsp自定义分页标签page等相关知识的信息别忘了在本站进行查找喔。