精华内容
下载资源
问答
  • java 分页

    千次阅读 2013-01-08 14:42:37
    在网上看了好多的struts2的分页,虽然都实现了分页的功能,但是感觉不是非常好,需要我们在每次写分页的时候做很多的工作,而我认为分页应该是一个通用的组件,开发人员在开发的过程中不应该在分页上花费太多的精力...

    在网上看了好多的struts2的分页,虽然都实现了分页的功能,但是感觉不是非常好,需要我们在每次写分页的时候做很多的工作,而我认为分页应该是一个通用的组件,开发人员在开发的过程中不应该在分页上花费太多的精力。所以,一直想封装一个比较通用的分页组件,而设计分页组件的时候,怎样保证动态查询的参数不丢失,成为实现的一个难点。         

    该组件采用自定struts2标签的方式实现。         

    首先建立一个构建分页标签信息的类:Pages.java

    /**
     * *构建分页标签体的类
     * *@authorJava软件工程师,艳子。
     * *@version1.0
     */
    public class Pages extends Component {
    	private HttpServletRequest request;
    	private String pageNo; // 当前页码
    	private String total; // 总页数
    	private String styleClass; // 分页的样式
    	private String theme; // 分页的主题
    	private String url; // action的路径
    	private String urlType; // 路径的类型,主要用于URL重写的扩展
    
    	// 省略get、set方法
    	public Pages(ValueStack arg0, HttpServletRequest request) {
    		super(arg0);
    		this.request = request;
    	}
    
    	@Override
    	public boolean end(Writer writer, String body) {
    		boolean result = super.start(writer);
    		try {
    			// 从ValueStack中取出数值
    			Object obj = this.getStack().findValue(pageNo);
    			pageNo = String.valueOf((Integer) obj);
    			obj = this.getStack().findValue(total);
    			total = String.valueOf((Integer) obj);
    
    			StringBuilder str = new StringBuilder();
    			Map cont = this.getStack().getContext();
    			StrutsRequestWrapper req = (StrutsRequestWrapper) cont
    					.get(StrutsStatics.HTTP_REQUEST);
    			if (url == null || "".equals(url)) {
    				url = (String) req
    						.getAttribute("javax.servlet.forward.request_uri");
    			}
    
    			String pageNoStr = "?pageNo=";
    			if ("dir".equals(urlType)) {
    				// 当url的类型为目录类型时,比如http://localhost:8090/yongtree/page/1
    				pageNoStr = "";
    				if ("1".equals(pageNo)) {// 第一页时
    					if (url.lastIndexOf("/") != url.length() - 1) {
    						if (url.lastIndexOf("1") == url.length() - 1) {// 如果有页码1,则去掉1
    							url = url.substring(0, url.length() - 1);
    						} else if (url.lastIndexOf("/") != url.length() - 1) {// 如果没有页码1,并且最后不是'/'时,加上'/'
    							url = url + "/";
    						}
    					}
    				} else {
    					url = url.substring(0, url.lastIndexOf("/") + 1);
    				}
    			}
    			// 下面这段处理主要是用来处理动态查询的参数,并拼接成url
    			StringBuffer perUrl = new StringBuffer("");
    			if (this.getParameters().size() != 0) {
    				Iterator iter = this.getParameters().keySet().iterator();
    				while (iter.hasNext()) {
    					String key = (String) iter.next();
    					Object o = this.getParameters().get(key);
    					perUrl.append("&").append(key).append("=").append(o);
    				}
    			}
    			Integer cpageInt = Integer.valueOf(pageNo);
    			str.append("<span ");
    			if (styleClass != null) {
    				str.append(" class='" + styleClass + "'>");
    			} else {
    				str.append(">");
    			}
    			// 文本样式
    			if (theme == null || "text".equals(theme)) {
    				// 当前页与总页数相等
    				if (pageNo.equals(total)) {
    					// 如果total = 1,则无需分页,显示“[第1页] [共1页]”
    					if ("1".equals(total)) {
    						str.append("[第 " + pageNo + " 页]");
    						str.append(" [共 " + total + " 页]");
    					} else {
    						// 到达最后一页,显示“[首页] [上一页] [末页]”
    						str.append("<a href='" + url + pageNoStr + "1" + perUrl
    								+ "'>[首页]</a> ");
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt - 1) + perUrl + "'>[上一页]</a>");
    						str.append(" <a href='" + url + pageNoStr + total
    								+ perUrl + "'>[末页]</a> ");
    					}
    				} else {
    					// 当前页与总页数不相同
    					if ("1".equals(pageNo)) {
    						// 第一页,显示“[首页] [下一页] [末页]”
    						str.append("<a href='" + url + pageNoStr + "1" + perUrl
    								+ "'>[首页]</a>");
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt + 1) + perUrl + "'>[下一页]</a>");
    						str.append("<a href='" + url + pageNoStr + total
    								+ perUrl + "'>[末页]</a>");
    					} else {
    						// 不是第一页,显示“[首页] [上一页] [下一页] [末页]”
    						str.append("<a href='" + url + pageNoStr + "1" + perUrl
    								+ "'>[首页]</a>");
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt - 1) + perUrl + "'>[上一页]</a>");
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt + 1) + perUrl + "'>[下一页]</a>");
    						str.append("<a href='" + url + pageNoStr + total
    								+ perUrl + "'>[末页]</a>");
    					}
    				}
    			} else if ("number".equals(theme)) {
    				// 数字样式 [1 2 3 4 5 6 7 8 9 10 > >>]
    				Integer totalInt = Integer.valueOf(total);
    				// 如果只有一页,则无需分页
    
    				str.append("[ ");
    				if (totalInt == 1) {
    					str.append("<strong>1</strong> ");
    				} else {
    					if (cpageInt > 1) {
    						// 当前不是第一组,要显示“<< <”
    						// <<:返回前一组第一页
    						// <:返回前一页
    						str.append("<a href='" + url + pageNoStr + "1" + perUrl
    								+ "'>?</a> ");
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt - 1) + perUrl);
    						str.append("'>‹</a> ");
    
    					} else {
    
    						str.append("? ‹ ");
    					}
    					int v = (cpageInt - 4) > 0 ? (cpageInt - 4) : 1;
    					int v1 = (cpageInt + 4) < totalInt ? (cpageInt + 4)
    							: totalInt;
    					if (v1 == totalInt) {
    						v = totalInt - 10;
    						v = (v <= 0 ? 1 : v); // 如果为负数,则修改为1
    					} else if (v == 1 && v1 < totalInt) {
    						v1 = totalInt > 10 ? 10 : totalInt;
    					}
    					// 10个为一组显示
    					for (int i = v; i <= v1; i++) {
    						if (cpageInt == i) { // 当前页要加粗显示
    							str.append("<strong>" + i + "</strong> ");
    						} else {
    							// str.append("<a href='"+url + i +perUrl+"'>" + i +
    							// "</a> ");
    							str.append("<a href='" + url + pageNoStr + i
    									+ perUrl + "'>" + i + "</a> ");
    						}
    					}
    					// 如果多于1组并且不是最后一组,显示“> >>”
    					if (cpageInt < totalInt) {
    						// >>:返回下一组最后一页
    						// >:返回下一页
    						str.append("<a href='" + url + pageNoStr
    								+ (cpageInt + 1) + perUrl);
    						str.append("'>›</a> ");
    						str.append("<a href='" + url + pageNoStr + totalInt
    								+ perUrl);
    						str.append("'>?</a> ");
    					} else {
    						str.append("› ? ");
    					}
    				}
    				str.append("]");
    			}
    			str.append("</span>");
    			writer.write(str.toString());
    		} catch (IOException ex) {
    			ex.printStackTrace();
    		}
    		return result;
    	}
    }

     

     

    自定义分页标签结构的类:PageTag.java

    /**
     * *自定义分页标签结构或属性
     * @author艳子, 
     * *@version1.0
     */
    public class PageTag extends ComponentTagSupport {
    	private String pageNo;
    	private String total;
    	private String styleClass;
    	private String theme;
    	private String url;
    	private String urlType;
    
    	public void setUrlType(String urlType) {
    		this.urlType = urlType;
    	}
    
    	public void setUrl(String url) {
    		this.url = url;
    	}
    
    	public void setTheme(String theme) {
    		this.theme = theme;
    	}
    
    	public void setStyleClass(String styleClass) {
    		this.styleClass = styleClass;
    	}
    
    	public void setPageNo(String pageNo) {
    		this.pageNo = pageNo;
    	}
    
    	public void setTotal(String total) {
    		this.total = total;
    	}
    
    	@Override
    	public Component getBean(ValueStack arg0, HttpServletRequest arg1,
    			HttpServletResponse arg2) {
    		return new Pages(arg0, arg1);
    	}
    
    	protected void populateParams() {
    		super.populateParams();
    		Pages pages = (Pages) component;
    		pages.setPageNo(pageNo);
    		pages.setTotal(total);
    		pages.setStyleClass(styleClass);
    		pages.setTheme(theme);
    		pages.setUrl(url);
    		pages.setUrlType(urlType);
    	}
    }


     

    创建自定义标签的tld文件

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
    <taglib>
    	<tlib-version>1.0</tlib-version>
    	<jsp-version>1.2</jsp-version>
    	<short-name>yt</short-name>
    	<uri>/yongtree-tags</uri>
    	<display-name>"Java软件工程师,专注于java领域新技术的研究和系统设计。的自定义标签"</display-name>
    	<tag>
    		<name>pages</name>
    		<tag-class>com.baiyyy.polabs.tag.PageTag</tag-class>
    		<body-content>jsp</body-content>
    		<description>分页标签</description>
    		<attribute>
    			<name>pageNo</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    		</attribute>
    		<attribute>
    			<name>total</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    		</attribute>
    		
    		<attribute>
    			<name>styleClass</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    			<description>分页标签的样式,不配置此项将采用默认的样式</description>
    		</attribute>
    		<attribute>
    			<name>theme</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    			<description>分页的主题,现支持number|text两种主题</description>
    		</attribute>
    		<attribute>
    			<name>url</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    			<description>分页提交的路径,默认不用配置该项,自动获取系统访问路径。</description>
    		</attribute>
    		<attribute>
    			<name>urlType</name>
    			<required>false</required>
    			<rtexprvalue>true</rtexprvalue>
    			<description>
    				url的类型,现在支持两种url类型,第一种默认的url,这种情况不需要设置;第二种情况是目录型的url,比如http://blog.csdn.net/yongtree,此种情况请配置成dir。此种情况不支持动态查询,故标签体中不能加入参数            </description>
    		</attribute>
    	</tag>
    </taglib>

     

    这样一个分页标签就实现完了,下一步让我们看看该怎样使用吧。  

    在页面中引入自定义的标签库: <%@ taglib prefix="yt" uri="/yongtree-tags"%>

    开始配置分页标签信息:

    <br>
    	共
    	<s:property value="total" />
    	页第
    	<s:property value="pageNo" />
    	页
    	<br>
    		<br>
    			<yt:pages pageNo="pageNo" total="total" styleClass="page"
    				theme="number"> <!—分页的动态查询参数需要全部注册在这里à     
    				<s:param name="test1" value="test1"></s:param>
    				<s:param name="test2" value="test2"></s:param>
    				<s:param name="test3" value="test3"></s:param>
    			</yt:pages>  


    这样一个分页组件就完成了,但是只是完成了表现上的功能,我们还需要在后台进行封装,我对它进行了封装,

    做了一个PageAction.java

    public class PageAction extends BaseAction {
    	private Integer pageNo = 1;
    	private Integer everyPage = 10;
    	private Integer total;
    	Page page = new Page();
    
    	public Integer getPageNo() {
    		return pageNo;
    	}
    
    	public void setPageNo(Integer pageNo) {
    		this.page.setCurrentPage(pageNo);
    		this.pageNo = pageNo;
    	}
    
    	public Integer getEveryPage() {
    		return everyPage;
    	}
    
    	public void setEveryPage(Integer everyPage) {
    		this.everyPage = everyPage;
    	}
    
    	public Page getPage() {
    		return page;
    	}
    
    	public void setPage(Page page) {
    		this.page = page;
    	}
    
    	public Integer getTotal() {
    		return this.page.getTotalPage();
    	}
    
    	public void setTotal(Integer total) {
    		this.total = total;
    	}
    }



     

    展开全文
  • Java分页原理

    万次阅读 2016-11-10 15:21:33
    Java分页 常见的分页实现方式 使用List接口中的subList(int startIndex, int endIndex)方法实现分页 直接使用数据库SQL语句实现分页 使用hibernate等框架实现跨数据库的分页 使用subList()实现分页 使用...

    Java分页

    常见的分页类型:

    • 传统的:采用传统的分页方式,可以明确的获取数据信息,如有多少条数据,分多少页显示等。
    • 下拉式:采用下拉式的分页方式,一般无法获取明确的数据数量相关的信息,但在分页操作以后,任然可以看到之前查询的数据。

    常见的分页实现方式:

    • 使用List接口中的subList(int startIndex, int endIndex)方法实现分页
    • 直接使用数据库SQL语句实现分页
    • 使用hibernate等框架实现跨数据库的分页

    使用subList()实现分页

    使用的是List接口中的subList(int startIndex, int endIndex)方法,返回列表中指定的fromIndex(包括)和endIndex(不包括)之间的部分视图。

    使用subList()

    使用数据库SQL语句实现分页
    mysql数据库使用limit关键字,oracle中使用rownum关键字。
    例如,从学生表(t_student)中查询出前十条数据
    MySql查询语句

    select * from t_student limit 0, 10
    

    表示的是从第0条开始取,取10条记录。

    PostgreSQL查询语句

    select * from t_student limit 10 offset 0
    

    Oracle查询语句
    Oracle查询语句

    使用hibernate框架实现跨数据库的分页
    使用hibernate框架实现跨数据库的分页

    分页实现方式的比较
    分页实现方式的比较

    实现方式

    模型对象

    处理映射数据表的对象外,还要创建一个Pager分页对象,其大致的内容如下:

    package com.imooc.page.model;
    
    import java.io.Serializable;
    import java.util.List;
    
    public class Pager<T> implements Serializable {
    
        private static final long serialVersionUID = -8741766802354222579L;
    
        //每页显示多少条记录
        private int pageSize;
        //当前第几页数据
        private int currentPage;
        //一共有多少条记录
        private int totalRecord;
        //一共多少页记录
        private int totalPage;
        //要显示的数据,使用泛型
        private List<T> dataList;
    
        public Pager() {
            super();
        }
    
        public Pager(int pageSize, int currentPage, int totalRecord, int totalPage, List<T> dataList) {
            super();
            this.pageSize = pageSize;
            this.currentPage = currentPage;
            this.totalRecord = totalRecord;
            this.totalPage = totalPage;
            this.dataList = dataList;
        }
    
        public Pager(int pageNum, int pageSize, List<T> sourceList){
            if (sourceList == null){
                return;
            }
    
            //总记录条数
            this.totalRecord = sourceList.size();
            //每页显示多少条记录
            this.pageSize = pageSize;
            //获取总页数
            this.totalPage = this.totalRecord / this.pageSize;
            if (this.totalRecord % this.pageSize != 0) {
                this.totalPage += 1;
            }
    
            //当前第几页数据
            this.currentPage = this.totalPage < pageNum ? this.totalPage : pageNum;
    
            //起始索引
            int fromIndex = this.pageSize * (this.currentPage - 1);
            //结束索引
            int toIndex =this.pageSize * this.currentPage > this.totalRecord ?  this.totalRecord :  this.pageSize * this.currentPage;
    
            this.dataList = sourceList.subList(fromIndex, toIndex);
        }
    
        public int getPageSize() {
            return pageSize;
        }
        public void setPageSize(int pageSize) {
            this.pageSize = pageSize;
        }
        public int getCurrentPage() {
            return currentPage;
        }
        public void setCurrentPage(int currentPage) {
            this.currentPage = currentPage;
        }
        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 List<T> getDataList() {
            return dataList;
        }
        public void setDataList(List<T> dataList) {
            this.dataList = dataList;
        }
        public static long getSerialversionuid() {
            return serialVersionUID;
        }
    
    
    
    }
    

    hibernate分页

    Dao的实现如下:

    package com.imooc.page.dao;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.hibernate.Query;
    import org.hibernate.Session;
    
    import com.imooc.page.Constant;
    import com.imooc.page.HibernateSessionFactory;
    import com.imooc.page.model.Pager;
    import com.imooc.page.model.Student;
    
    public class HibernateStudentDaoImpl implements StudentDao{
    
        @SuppressWarnings("unchecked")
        @Override
        public Pager<Student> findStudent(Student searchModel, int pageNum, int pageSize) {
            Pager<Student> result = null;
    
            //存放查询参数
            Map<String, Object> paramMap = new HashMap<String, Object>();
    
            String stuName = searchModel.getStuName();
            int gender = searchModel.getGender();
    
            StringBuilder hql = new StringBuilder(" from Student where 1=1");
            StringBuilder countHql = new StringBuilder("select count(id) from Student where 1=1");
    
            if(stuName != null && !stuName.equals("")){
                hql.append(" and stuName like :stuName");
                countHql.append(" and stuName like :stuName");
                paramMap.put("stuName","%" + stuName + "%");
            }
    
            if(gender == Constant.GENDER_MALE  || gender == Constant.GENDER_FEMALE){
                hql.append(" and gender = :gender");
                countHql.append(" and gender = :gender");
                paramMap.put("gender",gender);
            }
    
            //起始索引
            int fromIndex = pageSize * (pageNum - 1);
    
            List<Student> studentList = new ArrayList<Student>();
    
            Session session = null;
    
            try {
    
                session = HibernateSessionFactory.getSession();
                //获取query对象
                Query hqlQuery = session.createQuery(hql.toString());
                Query countHqlQuery = session.createQuery(countHql.toString());
                //设置查询参数
                setQueryParams(hqlQuery, paramMap);
                setQueryParams(countHqlQuery, paramMap);
    
                //从第几条记录开始查询
                hqlQuery.setFirstResult(fromIndex);
                //一共查询多少条记录
                hqlQuery.setMaxResults(pageSize);
    
                //获取查询的结果
                studentList = hqlQuery.list();
                //获取总计条数
                List<?> countResult = countHqlQuery.list();
    
                int totalRecord = ((Number)countResult.get(0)).intValue();
                //获取总页数
                int totalPage = totalRecord / pageSize;
                if (totalRecord % pageSize != 0) {
                    totalPage += 1;
                }
    
                //组装pager
                result  = new Pager<>(pageSize, pageNum, totalRecord, totalPage, studentList);
    
    
            } catch (Exception e) {
                throw new RuntimeException("查询所有数据异常!", e);
            }finally {
                if (session != null) {
                    HibernateSessionFactory.closeSession();
                }
            }
    
            return result;  
        }
    
        /**
         * 设置查询参数
         * @param query
         * @param paramMap
         * @return
         */
        private Query setQueryParams(Query query, Map<String, Object> paramMap){
            if(paramMap != null && !paramMap.isEmpty()){
                for(Map.Entry<String, Object> param : paramMap.entrySet()){
                    query.setParameter(param.getKey(), param.getValue());
                }
            }
            return query;
        }
    
    }
    

    对应的Servlet如下,这里使用到了fastjson返回json数据:

    package com.imooc.page.servlet;
    
    import java.io.IOException;
    import java.io.Writer;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.alibaba.fastjson.JSON;
    import com.imooc.page.Constant;
    import com.imooc.page.model.Pager;
    import com.imooc.page.model.Student;
    import com.imooc.page.service.HibernateStudentServiceImpl;
    import com.imooc.page.service.StudentService;
    import com.imooc.page.util.StringUtil;
    
    public class HibernateDataServlet extends HttpServlet {
    
        private StudentService studentService = new HibernateStudentServiceImpl();
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doPost(request, response);
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 接收request里的参数
            String stuName = request.getParameter("stuName"); //学生姓名
    
            // 获取学生性别
            int gender = Constant.DEFAULT_GENDER;
            String genderStr = request.getParameter("gender");
            if(genderStr!=null && !"".equals(genderStr.trim())){
                gender = Integer.parseInt(genderStr);
            }
    
            // 校验pageNum参数输入合法性
            String pageNumStr = request.getParameter("pageNum"); 
            if(pageNumStr !=null && !StringUtil.isNum(pageNumStr)){
                request.setAttribute("errorMsg", "参数传输错误");
                request.getRequestDispatcher("jdbcSqlStudent.jsp").forward(request, response);
                return;
            }
    
            int pageNum = Constant.DEFAULT_PAGE_NUM; //显示第几页数据
            if(pageNumStr!=null && !"".equals(pageNumStr.trim())){
                pageNum = Integer.parseInt(pageNumStr);
            }
    
            int pageSize = Constant.DEFAULT_PAGE_SIZE;  // 每页显示多少条记录
            String pageSizeStr = request.getParameter("pageSize");
            if(pageSizeStr!=null && !"".equals(pageSizeStr.trim())){
                pageSize = Integer.parseInt(pageSizeStr);
            }
    
            // 组装查询条件
            Student searchModel = new Student(); 
            searchModel.setStuName(stuName);
            searchModel.setGender(gender);
    
            //调用service 获取查询结果
            Pager<Student> result = studentService.findStudent(searchModel, 
                                                                    pageNum, pageSize);
            //不使用缓存
            response.setHeader("Cache-Control", "no-cache");  
            response.setHeader("Pragma", "no-cache");  
            //设置超时时间为0
            response.setDateHeader("Expires", 0);  
            //设置编码格式为utf-8
            response.setContentType("text/html;charset=utf-8");
    
            //获取查询数据的json格式
            String responseStr = JSON.toJSONString(result);
            //写入数据到response
            Writer writer = response.getWriter();
            writer.write(responseStr);
            writer.flush();
        }
    
        public static void main(String[] args) {
            String s = String.format("%05d", 123);
            System.out.println(s);
        }
    
    }
    

    分页插件

    参考

    展开全文
  • Java分页工具

    千次阅读 2019-05-24 11:26:28
    Java分页工具 import java.util.ArrayList; import java.util.List; /** * 分页 */ public class PageUtil<T>{ /** * 所有的记录 */ private List<T> allList=null; /** * 每页需要显...

     Java分页工具

    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 分页
     */
    public class PageUtil<T>{
    
        /**
         * 所有的记录
         */
        private List<T> allList=null;
        /**
         * 每页需要显示的数据
         */
        private List<T> pageList=null;
        /**
         * 所有记录总条数
         */
        private int sum=0;
        //每页显示记录条数
        private int per_record;
        /**
         * 总页数
         */
        private int page_counts=0;
        /**
         * 当前页
         */
        private int this_page=0;
    
        public PageUtil(List<T> list,int currentPage,int pageSize) {
            //配置每页显示记录数
            this.per_record=pageSize;
            //配置所有记录
            this.allList=list;
            //配置记录总数
            this.sum=this.allList.size();
            //配置总页数
            calculatePerRecord();
            //配置当前页页码
            setThisPage(currentPage);
            //配置当前页记录
            setThisList();
    
    
        }
        /**
         *
         * @Description:<p>配置当前页页码</p>
         */
        public void setThisPage(int Page) {
            if(Page<=1) {
                Page=1;
            }else if(Page>=this.page_counts) {
                Page=this.page_counts;
            }
            //内部真正页码是从0开始 所以减一
            this.this_page =Page-1;
            //每次设置页码的时候都从新配置一下当前页的数据
            setThisList();
        }
        /**
         *
         * @Description:<p>计算总页数</p>
         */
        private void calculatePerRecord() {
            //如果所有记录list为空,直接终止计算
            if(this.getAllList()==null) {
                return ;
            }
            //如果所有记录刚刚好整除每页显示的记录条数
            int sumPage=this.sum/this.per_record;
            //否则就多了一页不完全页
            if(this.sum%this.per_record>0) {
                ++sumPage;
            }
            this.page_counts = sumPage;
        }
    
        /**
         *
         * @Description:<p>配置当前页是数据</p>
         */
        private void setThisList(){
            //每页开始索引
            int index_start=this.this_page*this.per_record;
            //每页结束索引
            int index_end=(this.this_page+1)*this.per_record>this.allList.size()?
                    this.allList.size():(this.this_page+1)*this.per_record;
            //存数据进当前页之前 先清空当前页的数据
            this.pageList=new ArrayList();
    
            for (int i = index_start; i <index_end; ++i) {
                this.pageList.add(this.allList.get(i));
            }
        }
    
        public List<T> getAllList() {
            return allList;
        }
        public List<T> getPageList() {
            return pageList;
        }
        public int getSum() {
            return sum;
        }
        public int getPer_record() {
            return per_record;
        }
        /**
         *
         * @Description:<p>配置每页显示的记录条数</p>
         */
        public void setPer_record(int per_record) {
            this.per_record = per_record;
            //重新配置每页显示的记录条数后,需要重新配置总页数和当前页的记录
            setThisList();
            calculatePerRecord();
        }
    
        public int getPage_counts() {
            return page_counts;
        }
        public int getThis_page() {
            return this_page+1;
        }
    }
    
    

     

    展开全文
  • Java分页详细步骤

    千次阅读 2020-12-17 15:06:59
    Java分页详细步骤 需要理解的Java分页核心思想: 变量: 当前页码pageIndex 当前页面显示条数pageSize 总页码pageCount 需要写在sql语句中limit后的分页起始位置-结束位置:(pageIndex-1)*pageSize,pageSize service...

    Java分页详细步骤

    需要理解的Java分页核心思想:

    变量:

    • 当前页码pageIndex
    • 当前页面显示条数pageSize
    • 总页码pageCount
    • 需要写在sql语句中limit后的分页起始位置-结束位置:(pageIndex-1)*pageSize,pageSize

    service层(方法):
    1:Integer selectCount(Map<String,Object>map); 注:这里写获取数据库里所有数据条数
    2:List<实体类> selectList(Map<String,Object>map);注:这里写获取数据库所有数据

    xml(sql语句)
    1:< select id=“selectCount” parameterType=“Map” resultType=“Integer”>
    select count(1) from 表名
    </ select>
    2: < select id=“selectList” parameterType=“Map” resultType=“实体类”>
    select * from 表名 limit #{pageStart},#{pageEnd}
    </ select>

    Controller层:

    //这里写自动注入的service层,下面需要调用里面的方法
    @Autowired
    private Service service;

    //这里写前端传来的当前页码,其他变量直接在下面定义好就行了
    public AjaxResult list(@RequestParam(“pageIndex”) Integer pageIndex){
    //封装查询条件
    Map<String,Obvject> map = new HashMap<String,Obvject> ();
    //通过条件查询数据库总条数
    Integer count = service.selectCount(map);
    //初始化参数
    Integer pageCount=0;
    Integer pageSize=0;
    Integer pageStart=0
    Integer pageEnd=0;
    //获取总页码,总页码为数据库总条数取余当前页面显示条数,如果等于0既数据库总条数除以当前页面显示条数,否则是数据库总条数除以当前页面显示条数+1
    pageCount = count%pageSize==0?count/pageSize:count/pageSize+1;
    // 判断前端传过来的页码小于0或者大于总页码的情况
    if(pageIndex<0){
    pageIndex=0;
    }
    if(pageIndex>pageCount){
    pageIndex=pageCount;
    }

    //将上面得到的参数都放进map集合里
    map.put(“pageStart”,(pageIndex-1)*pageSize);
    map.put(“pageEnd”,pageSize);
    //执行查询,返回结果
    List<实体类>lists=service.selectList(map);
    //将前端需要的总条数存进map里,再将查询出来的lists也存进map里然后返回给前端
    map.put(“count”,count);
    map.put(“lists”,lists);
    return new AjaxResult(200,“分页查询数据”,map);
    }

    这就是后端全部处理过程,前端只需要传输pageIndex到后端就行了。新手上路,不喜勿喷,欢迎大神来讨论

    个人头像

    展开全文
  • Java分页工具实现方法

    2019-07-25 19:06:37
    分享一个java分页工具类 一位java小白的笔记!!!! 本实例也适用于web项目简单的翻页! 在项目中使用到了分页功能,记录下,以便以后使用。 直接上代码: public class PageableTool implements Serializable{ //...
  • java 分页查询工具类实现

    千次阅读 2019-05-06 15:38:57
    java分页查询后台实现 提到分页大家定当很熟悉,最近遇到前端框架更换之前的分页机制已不再适用,最终还是把上一个项目的分页机制拿过来使用,特在此记录一下,以免再次遇到此类情况! 后台代码实现 controller ...
  • java分页通用类

    千次阅读 2017-05-25 15:31:57
    java分页通用类 分页是个说简单就简单,说复杂页不复杂的功能。网上各种分页类多多少少都不符合自己的需求,还是自己写一个吧。   支持一个页面出现多个分页功能: Java代码  import ...
  • java分页查询接口的实现

    万次阅读 多人点赞 2017-02-07 18:56:15
    java分页查询的实现分页要传入当前所在页数和每页显示记录数,再分页查询数据库,部分代码如下所示。传入参数实体类:public class MessageReq { private String memberId;//会员id private int currentPage;//当前...
  • Java分页查询实现思路

    2016-05-30 09:29:09
    Java分页查询的实现思路是啥子,求大神讲解。为什么当前页-1获取到的是当前页码呢?
  • java分页数据导出excel

    千次阅读 2016-06-27 21:17:01
    下一篇 java分页数据导出excel
  • 求一个java分页的demo,有数据库,加前台的那种。谢谢了
  • JAVA分页完美解决方案

    2013-08-05 21:14:37
    JAVA分页完美解决方案  JAVA分页是个经典问题,本人从网上搜集资料,并通过编程,较为完美地决地了这个问题,浏览、增加、删除、修改、查看、搜索都可以回到原来的页码,源码已经上传CSDN,值得下载! 我的方案是用...
  • Java 分页功能

    千次阅读 2012-12-03 15:07:54
    一个简单的JAVA分页方法 定义两个Vector,一个为储存查询所有记录的totalV,另一个储存当前页的记录currentPageV; 总的记录数:int totalSize = totalV.getSize(); 每页显示的记录数:int countPerPage; 总...
  • 文章目录1 java 分页工具类(极简版)2 java 分页查询工具类(极简版)2.1 分页查询工具类2.2 java 防止 SQL 注入工具类3 mybatis mapper 文件中分页查询应用4 service 层分页查询的应用 1 java 分页工具类(极简版) ...
  • java分页算法

    千次阅读 2019-03-01 14:34:22
    Java常用分页计算 方法1 // 总条数 int totalRow = 101; // 每页记录数 int pageSize = 20; // 总页数 int totalPage = (totalRow - 1) / pageSize + 1; 方法2 // 总条数 int totalRow = 101; // 每页记录数 int pa....
  • Java分页之假分页

    万次阅读 2012-02-08 20:46:22
    分页,顾名思义,不是真正的在数据库里进行过滤,而是从数据库查询之后,取得全部结果,在展现的时候做些手脚。 import java.util.ArrayList; import java.util.List; public class Pager { /** * 当前页码 ...
  • Java分页原理及常用分页方法

    千次阅读 2017-11-27 23:21:59
    分页技术简介分页,是一种将所有数据分段展示给用户的技术.用户每次看到的不是全部数据,而是其中的一部分。如果在其中没有找到自习自己想要的内容,用户可以通过制定页码或是翻页的方式转换可见内容,直到找到自己想要...
  • java分页的写法

    千次阅读 2017-08-28 20:16:36
    第一步:  创建数据库,创建数据库所对应的一个实体类,... 创建另一个关于分页的实体类,里边只包含5项,如下可见 package com.qf.javabean; import java.util.List; public class PagStudent { private int cur
  • Java分页过滤器

    千次阅读 2019-02-11 09:26:16
    过滤器实现统一分页 过滤器实现(分页代码) import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.github.pagehelper.Page; import com.github.pagehelper.PageHelper; ...
  • java分页获取mongodb的大量数据并遍历处理 解决方法: 以下代码分页获取mongodb的数据并遍历处理,如果数据比较多,建议后台启动一个定时器去执行这些代码 MongoCollection<Document> collection = ...
  • java分页功能的实现

    2019-11-10 17:41:50
    在一个网站中分页是必不可少的,而实现原理相对来说比较简单。接下来分布讲解如何实现分页。 一.创建数据库(这里不过多介绍) 二.创建sql语句 分页实际上是每页显示多少条数据,我是使用Mysql来显示分页的,...
  • Java分页查询&条件查询

    万次阅读 2017-02-24 10:28:18
    1 分页查询 1.1 分页核心 设计一个用于封装当前页所有分页相关的数据的对象,叫分页对象PageBean /** * 分页对象。用于封装当前页的分页相关的所有数据 * @author h * */ public class PageBean { private List...
  • java分页,分成1、2、3、4、5页类型的和上一页下一页结合,谢谢!!!,想研究一下!!!已经会上一页下一页了!!!
  • Java分页显示

    千次阅读 热门讨论 2014-11-29 21:47:31
    分页是开发Web项目必有的一个功能,当用户查询需要显示数据的时候,大量的... Java实现分页的过程简单的说就是根据条件查询信息,服务器响应用户请求,返回用户查询结果,并以分页的形式显示出来。在这个过程中我们可
  • Java 分页计算公式

    2020-09-19 22:54:45
    1 根据传入的参数计算 1.1 请求参数(currPage:当前页、pageSize:每页展示条数),根据这两个参数计算起始起始条数、截止条数 起始条数 firstIndex = (currPage-1) * pageSize 截止条数 ......
  • java 分页读取数据

    千次阅读 2018-08-13 14:46:09
    /** * 查询总条数 * @return */ public Long querySize() { ...主要分享Java、golang架构,源码,分布式,高并发等技术,用大厂程序员的视角来探讨技术进阶、面试指南、职业规划等。15W技术人的选择!
  • java 分页工具类

    千次阅读 2015-05-26 09:51:06
    说明:曾经在网上看过花样繁多的分页,很多都号称如何通用,但很多时候往往不尽如人意:有在分页类中还加入URL地址信息的,有在分页类中还进行分页动作处理(此动作完全属于操作数据库方面的事情)的。现在好了,经...
  • Java分页查询(真分页)

    万次阅读 多人点赞 2017-06-06 10:54:04
    在开发过程中,我们经常会从数据库中查询数据,然后...当我们查询几百条以上数据,直接显示在一个页面上,不仅浏览不方便,查询效率也会受到影响,这是,我们就可以使用分页查询来解决这个问题。 分页思路   代码实现
  • java分页Page类

    万次阅读 2018-08-31 11:25:48
    public class Page implements Serializable { private int currentPageNum;//当前页 private int pageSize=5;//每页显示的条数 private int totalRecords;//总记录条数 private int startIndex;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 193,954
精华内容 77,581
关键字:

java分页

java 订阅