改进Spring中的分页技术

合集下载

前端开发中的数据分页与加载优化

前端开发中的数据分页与加载优化

前端开发中的数据分页与加载优化随着互联网的快速发展,前端开发在网站和应用的设计中扮演着重要的角色。

数据分页与加载优化是前端开发中一个关键的问题,它对于提供良好的用户体验以及减轻服务器负载都至关重要。

本文将探讨前端开发中的数据分页与加载优化的方法和技巧。

一、数据分页在前端开发中,分页是一种常见的数据处理方式。

当我们需要加载大量的数据时,为了避免页面卡顿和加载时间过长,我们可以将数据分成多个页面,按需加载。

下面是一些常见的数据分页的方法和注意事项。

1.1 分页组件前端框架中通常都有提供分页组件,可以根据需要选择相应的组件,并根据页面布局和样式进行定制。

分页组件可以方便地实现数据的分页和展示,并提供良好的用户交互体验。

1.2 后端接口设计在前端开发中,数据的分页是依赖后端接口的支持的。

因此,在设计后端接口时,需要考虑数据的分页逻辑。

通常使用的方式是通过参数传递页码和每页数据量,后端接口根据这些参数返回相应的数据。

1.3 数据加载方式在进行数据分页时,需要考虑数据的加载方式。

常见的数据加载方式有两种:前端加载和后端加载。

前端加载是指将所有数据一次性加载到前端,通过分页组件实现数据的分页展示。

这种方式能够提供更快的用户体验,但可能会导致浏览器负载过大,对于大数据量的情况不太适用。

后端加载是指每次只加载当前页数据,通过后端接口进行数据的分页。

这种方式可以减轻前端的负载,但可能会导致用户等待时间过长,对于网络较慢的情况可能影响用户体验。

根据实际情况选择适合的数据加载方式是很重要的,可以根据数据量大小、用户需求和网络条件进行权衡。

二、数据加载优化除了分页,数据加载优化也是前端开发中的一个重要问题。

优化数据加载可以提高页面加载速度,减轻服务器负载,从而提升用户体验。

下面是一些常见的数据加载优化方法和技巧。

2.1 懒加载懒加载是一种加载优化的方式,它的原理是在页面滚动到对应位置时再加载相关数据。

这种方式可以减少初次加载的数据量,提高页面加载速度。

前端开发中的单页应用与多页应用技术对比

前端开发中的单页应用与多页应用技术对比

前端开发中的单页应用与多页应用技术对比随着互联网的快速发展,前端开发技术也在不断进步。

在前端开发中,单页应用(SPA)和多页应用(MPA)是两种常见的开发模式。

本文将对这两种应用技术进行对比,探讨它们的优缺点以及适用场景。

一、单页应用(SPA)单页应用是指整个应用只有一个HTML页面,通过动态加载内容来实现页面的切换和更新。

在SPA中,前端使用JavaScript框架(如Angular、React、Vue等)来处理路由和页面渲染,与后端进行异步通信,实现数据的获取和更新。

单页应用的优点之一是用户体验更加流畅。

由于只需要加载一次HTML页面,后续的页面切换和更新都是通过异步请求和前端渲染完成,用户无需频繁刷新页面,减少了等待时间,提升了交互效果。

另一个优点是前后端分离开发。

SPA通过API接口与后端进行通信,前端开发人员可以专注于页面的交互逻辑和用户体验,而后端开发人员则负责提供数据接口。

这种分离的开发模式提高了开发效率和团队协作。

然而,SPA也存在一些缺点。

首先,由于整个应用只有一个HTML页面,页面中的JavaScript代码会变得庞大,导致页面加载速度变慢。

其次,SPA对搜索引擎的支持不够友好。

搜索引擎通常通过爬取HTML页面来获取网页内容,而在SPA中,大部分内容是通过JavaScript动态生成的,搜索引擎难以获取到完整的页面内容。

二、多页应用(MPA)多页应用是指每个页面都有一个独立的HTML文件,页面之间通过链接进行跳转。

在MPA中,前端开发人员使用HTML、CSS和JavaScript来构建页面,后端负责处理页面之间的跳转和数据的渲染。

多页应用的优点是对搜索引擎友好。

每个页面都有一个独立的URL,搜索引擎可以直接爬取每个页面的内容,提高了网站的搜索排名和曝光度。

另一个优点是页面加载速度相对较快。

由于每个页面都是独立的HTML文件,页面加载时只需要加载当前页面所需的资源,减少了不必要的资源浪费,提高了页面的加载速度。

SpringBoot项目中分页插件PageHelper无效的问题及解决方法

SpringBoot项目中分页插件PageHelper无效的问题及解决方法

SpringBoot项⽬中分页插件PageHelper⽆效的问题及解决⽅法在Springboot项⽬中使⽤分页插件的时候发现PageHelper插件失效了我导⼊的是:后来才发<dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.1.10</version></dependency>现 PageHelper若要在Springboot中使⽤是需要进⾏注⼊的:@Configurationpublic class mybatisConfiguration {@Beanpublic PageHelperpageHelper(){System.out.println("MybatisConfiguration.pageHelper()");PageHelper pageHelper =new PageHelper();Properties properties =new Properties();properties.setProperty("offsetAsPageNum","true");properties.setProperty("rowBoundsWithCount","true");properties.setProperty("reasonable","true");pageHelper.setProperties(properties);return pageHelper;}}当然也可使⽤Springboot PageHelper启动器⽆需注⼊开箱即⽤更推荐此⽅法:<dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper-spring-boot-starter</artifactId><version>1.2.10</version></dependency>PS:SpringBoot项⽬和Spring项⽬依赖分页插件Pagehelper不起作⽤的问题最近在SpringBoot项⽬和Spring项⽬同时开发,两个项⽬都依赖了Mybatis框架⾥的pagehelper分页插件,但是SpringBoot项⽬分页不起作⽤,⼀直查询出所有数据。

使用前端框架实现分页导航的方法

使用前端框架实现分页导航的方法

使用前端框架实现分页导航的方法在现代的网页设计中,分页导航被广泛应用于展示大量内容的页面,为用户提供方便快捷的浏览方式。

使用前端框架可以轻松地实现分页导航,并且提供了丰富的功能和样式定制选项。

本文将介绍常用的前端框架中实现分页导航的方法,并提供一些最佳实践。

一、Bootstrap框架Bootstrap是一款开源的前端框架,提供了丰富的组件和样式,广泛应用于网页设计和开发中。

要使用Bootstrap实现分页导航,首先需要引入Bootstrap的CSS和JS文件。

然后,在HTML中使用Navbar组件来创建导航栏,并使用Pagination组件来创建分页器。

Navbar组件可以通过简单的HTML代码创建一个固定的页眉导航栏,其中可以包含Logo、链接、表单等元素。

通过定制样式和布局,可以实现个性化的导航栏设计。

Pagination组件可以通过添加ul和li元素来创建一个分页器。

使用class="pagination"可以确保样式和功能的一致性。

通过调整样式和使用JavaScript来处理点击事件,可以实现分页导航的各种效果,例如ajax加载更多内容、跳转到指定页等。

二、Vue.js框架Vue.js是一款轻量级、灵活且易于上手的JavaScript框架,用于构建用户界面。

要使用Vue.js实现分页导航,首先需要引入Vue.js的文件。

然后,在HTML中定义一个Vue实例,并使用v-for指令来循环生成分页导航的链接。

在Vue实例中,可以使用v-model指令来绑定当前页数的数据,并通过计算属性来获得总页数。

然后,可以使用v-bind指令来动态绑定分页导航链接的样式和是否可点击的状态。

最后,通过使用v-on指令来绑定点击事件,以实现分页导航的功能。

Vue.js还提供了许多可用于扩展和定制的插件,如Vue Router用于处理路由导航,Vuex用于管理应用程序的状态等。

这些工具可以进一步增强分页导航的功能和性能。

springboot分页插件PageHelper的配置和使用方法

springboot分页插件PageHelper的配置和使用方法

springboot分页插件PageHelper的配置和使⽤⽅法前⾔ 在web开发过程中涉及到表格时,例如dataTable,就会产⽣分页的需求,通常我们将分页⽅式分为两种:前端分页和后端分页。

1)前端分页 ⼀次性请求数据表格中的所有记录(ajax),然后在前端缓存并且计算count和分页逻辑,⼀般前端组件(例如dataTable)会提供分页动作。

特点是:简单,很适合⼩规模的web平台;当数据量⼤的时候会产⽣性能问题,在查询和⽹络传输的时间会很长。

2)后端分页 在ajax请求中指定页码(pageNum)和每页的⼤⼩(pageSize),后端查询出当页的数据返回,前端只负责渲染。

特点是:复杂⼀些;性能瓶颈在MySQL的查询性能,这个当然可以调优解决。

⼀般来说,web开发使⽤的是这种⽅式。

我们说的也是后端分页。

MySQL对分页的⽀持简单来说MySQL对分页的⽀持是通过limit⼦句。

请看下⾯的例⼦。

limit关键字的⽤法是LIMIT [offset,] rowsoffset是相对于⾸⾏的偏移量(⾸⾏是0),rows是返回条数。

# 每页10条记录,取第⼀页,返回的是前10条记录select * from tableA limit 0,10;# 每页10条记录,取第⼆页,返回的是第11条记录,到第20条记录,select * from tableA limit 10,10;这⾥提⼀嘴的是,MySQL在处理分页的时候是这样的:limit 1000,10 - 过滤出1010条数据,然后丢弃前1000条,保留10条。

当偏移量⼤的时候,性能会有所下降。

limit 100000,10 - 会过滤10w+10条数据,然后丢弃前10w条。

如果在分页中发现了性能问题,可以根据这个思路调优。

Mybatis分页插件PageHelper在使⽤Java Spring开发的时候,Mybatis算是对数据库操作的利器了。

Spring的优缺点

Spring的优缺点

Spring的优缺点
1,降低了组件之间的耦合性,实现了软件各层之间的解耦。

2,可以使⽤容器提供的众多服务,如事务管理,消息服务等。

3,容器提供单例模式⽀持。

4,容器提供了AOP技术,利⽤它可以很容易实现⼀些拦截,如权限拦截,运⾏期监控等。

5,容器提供了众多的辅助类,能够加快应⽤的开发。

6,spring对于主流的应⽤框架提供了很好的⽀持,例如mybatis等。

7,spring属于低⼊侵式设计。

8,独⽴于各种应⽤服务器。

9,spring的DI机制降低了业务对象替换的复杂性。

10,spring的⾼度开放性,并不强制应⽤完全依赖于它,开发者可以⾃由选择spring的部分或者全部。

spring的缺点:
使⽤了⼤量的反射机制,反射机制⾮常占⽤内存。

掌握SpringBoot在前后端分离中的性能优化技巧

掌握SpringBoot在前后端分离中的性能优化技巧

掌握SpringBoot在前后端分离中的性能优化技巧Spring Boot是一种用于构建Java应用程序的框架,它提供了简化开发过程的自动化配置和约定优于配置的方法。

在前后端分离的应用中,性能优化是一项至关重要的任务。

本文将介绍一些用于优化SpringBoot应用在前后端分离中性能的技巧。

一、使用缓存机制在前后端分离的应用中,通常会存在大量的数据交互和频繁的请求操作。

为了减少对后端服务器的访问压力,可以引入缓存机制来减少对数据库的查询次数。

Spring Boot提供了多种缓存解决方案,如使用Redis、Ehcache等。

通过使用缓存,可以提高应用的响应速度和性能。

二、减少网络请求在前后端分离的架构中,前端向后端发送HTTP请求是一种常见的方式。

为了减少网络请求对应用的影响,可以采取以下措施:1. 合并请求:将多个相关的请求合并成一个,减少网络传输开销。

2. 压缩文件:使用压缩算法对前端发送的文件进行压缩,减少文件大小和传输时间。

3. 使用CDN加速:将静态资源部署到CDN上,可以提高资源加载速度,减少服务器资源消耗。

三、使用异步处理在前后端分离的应用中,通常会存在一些耗时的操作,如文件上传、邮件发送等。

为了避免这些操作对应用的性能产生影响,可以使用异步处理来进行解耦。

Spring Boot提供了异步处理的支持,可以使用@Async注解将某个方法标记为异步方法,从而提高应用的并发能力和响应速度。

四、合理使用数据库连接池在使用Spring Boot进行开发时,经常会与数据库进行交互。

为了提高性能,可以使用数据库连接池来管理数据库连接。

常见的数据库连接池有HikariCP、Druid等。

通过合理配置连接池的参数,可以提高数据库的连接效率,减少数据库连接的创建和销毁开销。

五、使用合适的缓存策略在前后端分离的应用中,缓存是一种提高性能的有效手段。

然而,过多的缓存可能导致内存消耗过大,而缓存过期不及时可能导致数据不一致。

Springboot中MyBatisplus使用IPage和Page分页的实例代码

Springboot中MyBatisplus使用IPage和Page分页的实例代码

Springboot中MyBatisplus使⽤IPage和Page分页的实例代码⼀、需求:实现Springboot中MyBatisplus使⽤IPage和Page分页⼆、技术:MyBatisplus的IPage和Page三、实现1、代码结构2、代码详情(1)Controllerpackage com.xkcoding.rbac.security.controller;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*;import java.util.Map;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.xkcoding.rbac.security.service.InterService;@Slf4j@RestController@RequestMapping("/inter")public class InterController {@Autowiredprivate InterService interService;@GetMapping("/test")public IPage<Map> test() {Integer currentPage = 1; //当前页数:显⽰第⼀页数据Integer pageSize = 2; //每页显⽰多少:每页显⽰2条数据Page<Map> page = new Page<Map>(currentPage, pageSize);IPage<Map> findList = interService.findlistpage(page);return findList;}}(2)Servicepackage com.xkcoding.rbac.security.service;import java.util.Map;import org.springframework.stereotype.Service;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.xkcoding.rbac.security.dao.InterDao;import org.springframework.beans.factory.annotation.Autowired;import lombok.extern.slf4j.Slf4j;@Slf4j@Servicepublic class InterService {@Autowiredprivate InterDao interDao;public IPage<Map> findlistpage(Page<Map> page) {return interDao.selectMapsPage(page, null);}}(3)Daopackage com.xkcoding.rbac.security.dao;import java.util.List;import java.util.Map;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.xkcoding.rbac.security.entity.Permission;public interface InterDao extends BaseMapper<Permission> {IPage<Map> selectMapsPage(Page<Map> page, QueryWrapper<List<Map<String, Object>>> wrapper);}(4)XML<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "http#{///dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.xkcoding.rbac.security.dao.InterDao"><select id="selectMapsPage" resultType="java.util.Map" parameterType="java.util.Map">SELECT * FROM INTER_COLLECTION</select></mapper>(5)实体类package com.xkcoding.rbac.security.entity;import lombok.Data;@Datapublic class Inter {private String id;private String interName;private String mode;private String selectStatement;private String insertStatement;private String updateStatement;private String interEnable;private String interParam;private String interType;private String tableName;}3、运⾏结果以上⽤到的 lombok 注解:@Data:注解在类上;提供类所有属性的 getting 和 setting ⽅法,此外还提供了equals、canEqual、hashCode、toString ⽅法@Slf4j:注解在类上;为类提供⼀个属性名为log 的 log4j ⽇志对象到此这篇关于Springboot中MyBatisplus使⽤IPage和Page分页的⽂章就介绍到这了,更多相关MyBatisplus使⽤IPage和Page分页内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

oracle+mybatis-plus+springboot实现分页查询的实例

oracle+mybatis-plus+springboot实现分页查询的实例

oracle+mybatis-plus+springboot实现分页查询的实例今天蠢了⼀上午才弄出这玩意,话不多说上代码!1、建⼀个配置类package com.sie.demo.config;import com.baomidou.mybatisplus.annotation.DbType;import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author liaozhifeng* @date 2021/7/31 11:14* @Version 1.0*/@Configuration@ConditionalOnClass(value = {PaginationInterceptor.class})public class MybatisPlusConfig {// 最新版@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();// 数据库的配置DbType.ORACLE 根据⾃⼰的数据库选择interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.ORACLE));return interceptor;}}2、service层的代码package com.sie.demo.service.impl;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import ers;import com.sie.demo.entity.vo.PageUserVo;import erMapper;import erService;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Service;import org.springframework.util.DigestUtils;import javax.annotation.Resource;import javax.servlet.http.HttpSession;import java.util.List;/*** @author liaozhifeng* @date 2021/7/27 14:03* @Version 1.0*/@Service@Slf4jpublic class UserServiceImpl extends ServiceImpl<UserMapper, Users> implements UserService {@ResourceUserMapper userMapper;/*** 分页查询⽤户* @param currentPage* @param pageSize* @return*/@Overridepublic PageUserVo selectAll(long currentPage, long pageSize) {IPage<Users> userPage = new Page<>(currentPage, pageSize);//参数⼀是当前页,参数⼆是每页个数IPage<Users> iPage = userMapper.selectPage(userPage, null);List<Users> list = iPage.getRecords();Long total = iPage.getTotal();PageUserVo pageUserVo = new PageUserVo(list, total);return pageUserVo;}}3、controller层 RetResult是我⾃⼰定义的⼀个统⼀返回的泛型对象package com.sie.demo.controller;import com.baomidou.mybatisplus.core.conditions.Wrapper;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.sie.demo.entity.RetCode;import com.sie.demo.entity.RetResponse;import com.sie.demo.entity.RetResult;import ers;import com.sie.demo.entity.vo.PageUserVo;import erServiceImpl;import com.sie.demo.util.TokenUtil;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.*;import javax.annotation.Resource;import javax.servlet.http.HttpSession;import java.util.List;@Controller@RestController@RequestMapping("user")@Slf4jpublic class UserController {@AutowiredUserServiceImpl userService;/***** @param currentPage* @param pageSize* @return*/@GetMapping("selectAll")public RetResult<PageUserVo> selectAll(long currentPage, long pageSize) {(currentPage+pageSize+"=========================");PageUserVo pageUserVo = userService.selectAll(currentPage,pageSize);return RetResponse.makeOKRsp(pageUserVo);}}到此这篇关于oracle+mybatis-plus+springboot实现分页查询的实例的⽂章就介绍到这了,更多相关 mybatis-plus springboot分页查询内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

SpringDataJpa使用原生sql(EntityManager)动态拼接,分页查询

SpringDataJpa使用原生sql(EntityManager)动态拼接,分页查询

SpringDataJpa使⽤原⽣sql(EntityManager)动态拼接,分页查询SpringDataJpaSpring Data JPA是较⼤的Spring Data系列的⼀部分,可轻松实现基于JPA的存储库。

该模块处理对基于JPA的数据访问层的增强⽀持。

它使构建使⽤数据访问技术的Spring⽀持的应⽤程序变得更加容易。

实现应⽤程序的数据访问层已经很长⼀段时间了。

为了执⾏简单查询以及执⾏分页和审核,必须编写太多样板代码。

Spring Data JPA旨在通过将⼯作量减少到实际需要的数量来显着改善数据访问层的实现。

作为开发⼈员,您将编写包括⾃定义finder⽅法在内的存储库接⼝,Spring会⾃动提供实现。

使⽤EntityManager 来创建原⽣查询语句在service层的代码:@PersistenceContextEntityManager entityManager;@Overridepublic Object findMeetingSignRecoredPage(Long meetingId, Integer pageIndex, Integer pageSize) {MeenoAssert.notNull(meetingId, ErrEnum.MEETING_ID_IS_EMPTY);Meeting meeting = this.meetingRepository.getOne(meetingId);MeenoAssert.notNull(meeting,ErrEnum.MEETING_IS_NOT_EXIST);Pageable pageable = PageUtils.getPageable(pageIndex,pageSize);StringBuilder sql = new StringBuilder();sql.append(" select ,MAX(r.sign) from mnt_emp_rel_meeting as e ");sql.append(" left join mnt_sign_record as r on(r.employee_id=e.employee_id) ");sql.append(" left join mnt_employee as ep on(ep.id = e.employee_id) ");sql.append(" where e.meeting_id = ? ");sql.append(" order by r.sign desc,r.create_date asc ");Query query = entityManager.createNativeQuery(sql.toString());query.setFirstResult(pageable.getOffset());query.setMaxResults(pageable.getPageSize());query.setParameter(1,meetingId);List<Object[]> list = query.getResultList();List<SignRecordView> listView = Lists.newArrayList();if(list != null && !list.isEmpty()){for (Object[] objects : list) {String empName = objects[0]==null?null:objects[0].toString();Integer sign = objects[1]==null?Constants.SIGN_RECORD_NO:Integer.parseInt(objects[1].toString());SignRecordView view = new SignRecordView();view.setEmployeeName(empName);view.setSign(sign);listView.add(view);}}//countStringBuilder countSql = new StringBuilder();countSql.append(" select count(distinct e.id) from mnt_emp_rel_meeting as e ");countSql.append(" left join mnt_sign_record as r on(r.employee_id=e.employee_id) ");countSql.append(" left join mnt_employee as ep on(ep.id = e.employee_id) ");countSql.append(" where e.meeting_id = ? ");countSql.append(" order by r.sign desc,r.create_date asc ");Query countQuery = entityManager.createNativeQuery(countSql.toString());countQuery.setParameter(1,meetingId);Object singleResult = countQuery.getResultList().get(0);Integer count = singleResult==null?0:Integer.valueOf(singleResult.toString());Map<String, Object> resultPage = PageUtils.getResultPage(count, listView);return resultPage;}PageUtils⼯具类代码如下:package com.meeno.framework.page.utils;import mon.collect.Lists;import mon.collect.Maps;import lombok.Data;import org.springframework.data.domain.Page;import org.springframework.data.domain.PageRequest;import org.springframework.data.domain.Pageable;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Map;/*** @description: 分页⼯具类* @author: Wzq* @create: 2019-12-26 20:19*/@Datapublic class PageUtils {/***@Description 获取集合分页对象*@Param [list, pageIndex, pageSize]*@Return void*@Author Wzq*@Date 2020/1/6*@Time 14:07*/public static <T> Map<String,Object> getCollectionPage(List<T> list, Pageable pageable){ if(list==null||list.isEmpty()){return PageUtils.getResultPage(0,null );}int offset = pageable.getOffset();int pageSize = pageable.getPageSize();List<T> listView = Lists.newArrayList();if(list!=null && !list.isEmpty()){if(list.size() < offset){return PageUtils.getResultPage(0,null );}for(;list.size() > offset && pageSize != 0 ; offset++,pageSize--){listView.add(list.get(offset));}return PageUtils.getResultPage(list.size(),listView);}return PageUtils.getResultPage(0,null );}/***@Description 根据pageIndex和pageSize获取Pageable*@Param [pageIndex, pageSize]*@Return org.springframework.data.domain.Pageable*@Author Wzq*@Date 2019/12/27*@Time 11:12*/public static Pageable getPageable(Integer pageIndex, Integer pageSize){if(pageIndex==null){pageIndex = 0;}else{pageIndex--;}if(pageSize==null){pageSize = 10;}PageRequest pageRequest = new PageRequest(pageIndex, pageSize);return pageRequest;}/***@Description 获取分页返回对象*@Param [totalCount, list]*@Return java.util.Map<ng.String,ng.Object>*@Author Wzq*@Date 2019/12/26*@Time 20:22*/public static Map<String,Object> getResultPage(Page<?> page, List<?> list){ Map<String,Object> resultPageMap = Maps.newHashMap();resultPageMap.put("totalCount",page.getTotalElements());resultPageMap.put("list",list);return resultPageMap;}public static Map<String,Object> getResultPage(Integer count, List<?> list){ Map<String,Object> resultPageMap = Maps.newHashMap();resultPageMap.put("totalCount",count);resultPageMap.put("list",list);return resultPageMap;}}。

大数据量的分页解决方法

大数据量的分页解决方法

大数据量的分页解决方法随着互联网和信息技术的快速发展,数据量的爆发式增长已经成为了大势所趋。

在处理大数据量时,分页是一种常见的需求。

分页可以将大量的数据划分成小块进行展示,使得用户可以方便地浏览和查找所需的信息。

本文将介绍几种常见的大数据量分页解决方法。

一、传统分页方式传统的分页方式是通过数据库的查询语句来实现的。

通过设置查询的起始位置和返回的数量,可以实现数据的分页展示。

这种方式简单直接,但是在处理大数据量时存在效率问题。

因为数据库需要扫描整个数据表,然后再返回指定的数据量,对于数据量特别大的情况下,会导致查询速度变慢,甚至引起数据库连接超时等问题。

二、索引分页方式为了解决传统分页方式的效率问题,可以利用数据库的索引来进行分页。

数据库的索引是对数据表中的某一列或多列进行排序的结构,可以加快数据的查找速度。

通过在需要分页的列上建立索引,可以在查询时快速定位到指定的数据位置,从而提高查询效率。

三、缓存分页方式缓存分页是指将大数据集的部分数据缓存在内存中,供用户随时查询。

这种方式可以大大提高数据的访问速度,减轻数据库的压力。

常见的缓存技术有Redis和Memcached等。

通过将数据缓存在内存中,可以快速响应用户的请求,提高用户体验。

四、分布式分页方式分布式分页是指将大数据集分布在多个服务器上进行处理。

这种方式可以充分利用多台服务器的计算能力,提高数据的处理效率。

常见的分布式计算框架有Hadoop和Spark等。

通过将数据分片存储在不同的服务器上,并利用并行计算的能力,可以快速地对大数据集进行分页操作。

五、搜索引擎分页方式搜索引擎分页是指将大数据集建立索引,然后通过搜索引擎进行查询。

搜索引擎可以根据用户的搜索关键词,快速定位到符合条件的数据,并进行分页展示。

常见的搜索引擎有Elasticsearch和Solr 等。

通过将数据建立索引,可以快速地进行全文搜索,并实现高效的分页展示。

六、无限滚动分页方式无限滚动分页是指在页面中动态加载数据,实现无限滚动的效果。

JSP框架中的页面布局与渲染优化

JSP框架中的页面布局与渲染优化

JSP框架中的页面布局与渲染优化随着构建大型Web应用程序变得越来越普遍,使用Java作为服务器端编程语言的开发者需要了解如何构建高效,高性能的应用程序。

JSP (JavaServer Pages)是一种常见的Java Web编程技术,可以帮助开发人员生成动态Web页面。

在使用JSP框架时,页面布局和渲染优化是至关重要的。

页面布局优化在构建Web页面时,最重要的是考虑页面布局。

优化页面布局将减轻用户体验,并且可以节省服务器资源。

以下是一些JSP框架中的页面布局优化建议:1. 尽量使用CSS(层叠样式表)控制页面布局。

CSS将样式与布局分离,可以更好地实现重用代码,并减少页面加载时间。

在使用JSP框架时,将布局信息存储在CSS文件中,这将使页面更具可维护性和可扩展性。

2. 最小化HTML(超文本标记语言)标记。

HTML标记可以增加页面加载时间,并降低页面性能。

在使用JSP框架时,应该尽量减少HTML标记的数量。

例如,可以使用较少的标记和嵌套层数来设计页面布局。

减少HTML标记数量的另一个好处是能够提高搜索引擎的排名。

这是因为搜索引擎更喜欢干净,有效的HTML代码。

3. 尽可能避免使用表格布局。

表格布局具有复杂性和低效性,应该尽量避免使用。

在使用JSP框架时,可以使用CSS布局替代表格布局。

4. 使用JavaScript生成动态布局。

在生成动态布局时,可以使用JavaScript动态生成布局信息。

这可以减少网络流量,并改善用户体验。

渲染优化在构建Web应用程序时,还要优化页面渲染。

页面渲染是将HTML代码转换为用户可视页面的过程。

以下是一些JSP框架中的页面渲染优化建议:1. 最小化JavaScript标记位置。

在将JavaScript标记嵌入HTML代码中时,应该尽可能将它们放在HTML代码的底部。

这将减少页面加载时间,并使得在页面渲染完成之前JavaScript代码可以处理页面内容和事件。

2. 压缩和缩小HTML,CSS和JavaScript。

reactivecrudrepository 分页 -回复

reactivecrudrepository 分页 -回复

reactivecrudrepository 分页-回复什么是ReactiveCrudRepository?ReactiveCrudRepository是Spring Data提供的一种接口,用于在响应式编程环境下进行数据操作。

它是CrudRepository的一个扩展,用于处理持久化操作,如创建、读取、更新和删除等。

ReactiveCrudRepository提供了一组用于操作持久化数据的方法,并为开发人员提供了一种轻松地执行CRUD操作的方式。

它使用了许多响应式编程的概念和技术,使开发人员能够更高效地处理数据。

本文将介绍ReactiveCrudRepository的主要特性和用法,并提供一些代码示例来说明如何使用它进行分页操作。

首先,我们需要在项目中引入Spring Data依赖。

可以使用Maven或Gradle来管理项目依赖,下面是一个Maven的示例配置:xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency>接下来,我们需要创建一个继承自ReactiveCrudRepository的接口来处理数据持久化操作。

例如,我们可以创建一个名为UserRepository的接口来处理用户数据的CRUD操作:javaimportorg.springframework.data.repository.reactive.ReactiveCrudReposit ory;public interface UserRepository extends ReactiveCrudRepository<User, Long> {}在上面的示例中,UserRepository接口继承了ReactiveCrudRepository 接口,并指定了实体类User和ID类型Long作为泛型参数。

SpringBoot整合PageHelper实现分页查询功能详解

SpringBoot整合PageHelper实现分页查询功能详解

SpringBoot整合PageHelper实现分页查询功能详解前⾔本⽂介绍的是MyBatis 分页插件 PageHelper,如果你也在⽤ MyBatis,建议尝试该分页插件,这⼀定是最⽅便使⽤的分页插件。

分页插件⽀持任何复杂的单表、多表分页。

使⽤⽅法导⼊依赖在中央仓库中搜索pageHelper,找到pagehelper-spring-boot-starter可以⾃选版本,选择你所使⽤的依赖管理⼯具对应的依赖坐标,例如我⽤的依赖管理⼯具是Maven,那我就选择对应Maven的依赖坐标。

添加pagehelper-spring-boot-starter的Maven依赖<dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper-spring-boot-starter</artifactId><version>1.4.1</version></dependency>添加该依赖之后⽆需再添加MyBatis的依赖,因为该依赖默认依赖了MyBatis:编写配置⽂件使⽤yaml格式:pagehelper:helper-dialect: mysqlreasonable: truesupport-methods-arguments: trueparams: count=countSql使⽤properties格式:# 指定分页插件的⽅⾔pagehelper.helper-dialect=mysql# 分页合理化pagehelper.reasonable=true# ⽀持⽅法参数pagehelper.support-methods-arguments=true#配置参数映射pagehelper.params=count=countSql参数说明:可参考官⽅⽂档准备数据表准备Mapper接⼝测试查询全部数据运⾏结果:默认SQL语句就是查询全部数据PageHelper 分页查询使⽤PageHelper.startPage(pageNum,pageSize)⽅法来设置分页信息,分别是当前页数和每页显⽰的总记录数注意:必须在mapper接⼝中的⽅法执⾏之前设置该分页信息运⾏结果:PageHelper.startPage(pageNum,pageSize)⽅法只对后⾯⼀次查询⽣效下⾯有2次查询所有数据,第1次查询所有数据前插⼊了PageHelper.startPage(pageNum,pageSize)⽅法,所以第1次查询是分页查询,⽽第2次查询前没有插⼊PageHelper.startPage(pageNum,pageSize)⽅法,所以不是分页查询。

struts2+spring+hibernate分页显示完整代码

struts2+spring+hibernate分页显示完整代码

分页显示一直是web开发中一大烦琐的难题,传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码,那样做分页可能简单一点,但当把网站分层开发后,分页就比较困难了,下面是我做Spring+Hibernate+Struts2项目时设计的分页代码,与大家分享交流。

1、DAO层接口的设计,在MemberDao接口中定义了如下两个方法:publicinterface MemberDao {@SuppressWarnings("unchecked")/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/public List queryForPage(final Stringhql,finalint offset,finalint length);/*** 查询所有记录数* @param hql查询的条件* @param offset 开始记录* @return总记录数*/publicint getAllRowCount(String hql);}2、DAO层实现类MemberDaoImpl对上面两个方法的实现如下:publicclass MemberDaoImpl extends HibernateDaoSupport implements Me mberDao {/*** 查询所有记录数* @return总记录数*/publicint getAllRowCount(String hql) {return getHibernateTemplate().find(hql).size();}/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/@SuppressWarnings("unchecked")public List queryForPage(final String hql, finalint offset, finalint length) {List list =getHibernateTemplate().executeFind(new HibernateCallback(){ public Object doInHibernate(Session session)throws HibernateException, SQLException {Query query = session.createQuery(hql);query.setFirstResult(offset);query.setMaxResults(length);List list = query.list();return list;}});return list;}}细心的读者会发现,这个类继承了HibernateDaoSupport类,HibernateDaoSupport是Spring 提供的对Hibernate支持的类,getHibernateTemplate().executeFind(new HibernateCallback(){....})方法中的参数,我们使用了接口回调,在其参数内,我们能像原生的Hibernate一样调用query.setFirstResult(offset)和query.setMaxResults(length)来实现分页查询功能。

前端开发技术实现分页功能的方法

前端开发技术实现分页功能的方法

前端开发技术实现分页功能的方法现如今,互联网的快速发展使得网页的内容变得越来越丰富和庞大,这就给前端开发带来了很大的挑战。

用户很难一次性加载并浏览完全部的内容。

因此,实现分页功能成为了前端开发过程中必备的技术之一。

分页是一种将数据分割成不同页面进行展示的方式,用户可以通过点击分页器或滚动来浏览内容,从而提升用户体验和性能。

在前端开发中,实现分页功能有以下几种方法。

1. 传统分页最常见的分页方式就是传统的分页方式。

在这种方式下,后端会根据前端传递的页码和每页显示数量,返回对应页码的数据。

前端收到数据后,根据返回的数据进行渲染。

该方式简单易懂,但有一定的性能问题,因为每次加载新的页面都需要向后端请求数据。

2. 懒加载懒加载是一种更加智能和高效的分页方式。

它会根据用户的滚动行为动态加载新的数据,而不是一次性将所有数据加载完毕。

懒加载可以提升整体的页面加载速度,并且减轻了服务器的压力。

在懒加载中,分页功能可以通过监听滚动事件,当用户滚动到页面底部时,自动加载下一页的数据。

这种方式可以利用一些插件或库来实现,如Intersection Observer。

3. 无限滚动无限滚动是一种类似于懒加载的方式,它可以无限地加载数据,用户可以不断滚动浏览新的内容。

在无限滚动中,页面会根据用户的滚动行为自动加载下一页的内容,并在当前内容末尾添加新的数据。

这种方式可以提升用户的浏览体验,并减少页面的跳转次数。

它可以通过监听滚动事件,当用户滚动到页面底部时,自动加载下一页的数据。

同样的,也可以使用一些插件或库来实现。

4. 利用URL参数前端还可以通过URL参数来实现分页功能。

在这种方式下,用户的操作会通过改变URL参数的方式来实现分页。

当用户点击分页器时,会改变URL参数的值,并重新加载页面。

前端可以通过解析URL参数来获取相应的页码,并从后端请求对应页码的数据。

这种方式能够在用户操作后进行前进或后退,方便用户对内容的查看和导航。

springboot实现layui分页前后端数据动态交互功能

springboot实现layui分页前后端数据动态交互功能

springboot实现layui分页前后端数据动态交互功能最近在学layui这个前端框架的分页功能,官⽅的⽂档中,给出的分页样式如下图所⽰:1<!DOCTYPE html>2<html>3<head>4<meta charset="utf-8">5<title>layPage快速使⽤</title>6<!--注意:这⾥引⼊的样式路径是你本地对应的路径-->7<link rel="stylesheet" href="layui/css/layui.css" media="all">8</head>9<body>1011<div id="test1"></div>12<!--注意:这⾥引⼊的样式路径是你本地对应的路径-->13<script src="layui/layui.js"></script>14<script>15 e('laypage', function(){16var laypage = ypage;1718//执⾏⼀个laypage实例19 laypage.render({20 elem: 'test1' //注意,这⾥的 test1 是 ID,不⽤加 # 号21 ,count: 50 //数据总数,从服务端得到22 });23 });24</script>25</body>26</html>执⾏后得到的效果如下图所⽰:作为后端的java开发,有时候需要⽤到这个分页的功能,所以想着来结合layui分页做⼀个前后端数据交互分页。

reactivecrudrepository 分页 -回复

reactivecrudrepository 分页 -回复

reactivecrudrepository 分页-回复ReactiveCrudRepository 分页是什么?在现代的软件开发中,数据操作和处理是非常重要的一环。

而对于数据库的操作,常常需要进行分页查询。

分页查询是指在查询操作中,按照指定的页码和每页显示的数量,将查询的结果划分成一页一页的数据返回给用户。

在实际的应用中,我们需要根据实际情况,划定每一页的数据量,以便提供更好的用户体验。

对于Spring Data框架来说,提供了一个非常强大且灵活的分页查询解决方案。

其中,ReactiveCrudRepository是Spring Data的一部分,它是一个接口,用于处理与数据库的基本交互操作,并且支持响应式编程模型。

具体而言,它提供了如下几个功能:1. 插入数据:ReactiveCrudRepository提供了一系列的插入方法,可以用于将数据插入到数据库中。

这些方法使开发者能够方便地进行数据的持久化操作。

在插入数据时,我们可以通过设置返回的Publisher,从而实现异步的数据插入操作。

2. 查询数据:ReactiveCrudRepository通过提供一系列的查询方法,使开发者能够方便地进行数据查询操作。

这些方法包括通过主键查询、通过指定字段查询、按照条件查询等等。

而在分页查询方面,ReactiveCrudRepository提供了更为便捷的方法,通过指定页码和每页显示的数量,即可获取到分页查询的结果。

3. 更新数据:除了插入和查询操作之外,ReactiveCrudRepository还支持数据的更新操作。

开发者可以更新指定的数据,并将其持久化到数据库中。

这样,我们就可以使用ReactiveCrudRepository来在业务逻辑中实现更新操作,例如更改用户的密码、更新订单的状态等。

4. 删除数据:最后,ReactiveCrudRepository还提供了数据删除的方法。

通过指定要删除的数据,我们可以方便地删除数据库中的相关记录。

数据库中的分页查询优化技巧总结

数据库中的分页查询优化技巧总结

数据库中的分页查询优化技巧总结分页查询是在数据库中处理大量数据时常用的一种查询方式。

在实际应用中,我们经常需要从数据库中查询大量数据并将其分页显示,以提供更好的用户体验。

然而,随着数据量的增加,分页查询的效率往往会受到限制。

因此,优化分页查询是数据库开发中的关键技巧之一。

下面,将介绍一些常用的分页查询优化技巧。

1. 使用适当的索引索引是数据库查询性能优化的关键因素之一。

在分页查询中,通过适当地创建索引可以显著提高查询效率。

对于分页查询,应将索引放在用于排序和分页的列上,这样可以避免全表扫描的开销,提高查询性能。

2. 避免使用 SELECT *在进行分页查询时,应尽量避免使用 SELECT * 查询所有列的方式。

因为这会导致查询的数据量巨大,对数据库的性能造成不必要的开销。

只选择需要的列可以减少数据库的负载,提高查询速度。

3. 使用 LIMIT 和 OFFSET在进行分页查询时,应该使用数据库提供的 LIMIT 和 OFFSET 关键字来确定查询返回的结果集范围。

LIMIT 定义了每页返回的记录数,OFFSET 定义了查询结果从哪一行开始。

合理设置这两个参数可以减少数据库的查询开销。

4. 使用更高效的分页查询方式除了使用 LIMIT 和 OFFSET 外,还可以考虑使用其他更高效的分页查询方式。

例如,MySQL 中的游标技术可以通过占用少量内存进行快速分页,并且支持在数据集的起点、中间和终点进行分页。

根据实际需求,选择合适的分页查询方式可以提高查询速度。

5. 使用缓存技术分页查询经常会进行多次查询,而且在查询过程中可能会存在数据变动的情况。

为了提高查询速度,可以使用缓存技术。

将查询结果缓存在内存中,可以减少数据库的查询次数,提升系统的响应速度。

6. 数据预加载在分页查询中,如果需要加载与当前查询结果相关的额外数据,可以考虑进行数据预加载。

将相关数据一并查询出来,避免后续的多次查询操作,可以减少数据库的负载,提高查询效率。

springboot学习----使用pageHelper实现分页功能

springboot学习----使用pageHelper实现分页功能

springboot学习----使⽤pageHelper实现分页功能⽬录 1.介绍pageHelper 2.pageHelper的基本配置 3.使⽤pageHelper实现分页功能 pageHelper是⼀款分页插件,它能很好的集成在spring boot中在它是⼀个基于mybatis的⼀款插件。

它是的底层实现技术则是使⽤动态代理实现的。

所以我们在使⽤它时,我们需要使⽤mybatis作为持久层框架。

如果有需要请参照《spring boot 集成 mybatis》 如果我们需要使⽤pageHelper的话,我们需要在spring boot项⽬中引⼊pageHelper的依赖。

以下是PageHelper的GitHub地址 在这⾥我们导⼊以下依赖:<!-- pagehelper --><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper-spring-boot-starter</artifactId><version>1.2.5</version></dependency> 同样,我们在spring boot的application.properties中可以配置pageHelper的基本信息,# 指定数据库,不指定的话会默认⾃动检测数据库类型pagehelper.helperDialect=mysql# 是否启⽤分页合理化。

# 如果启⽤,当pagenum<1时,会⾃动查询第⼀页的数据,当pagenum>pages时,⾃动查询最后⼀页数据;# 不启⽤的,以上两种情况都会返回空数据pagehelper.reasonable=true# 默认值false,分页插件会从查询⽅法的参数值中,⾃动根据上⾯ params 配置的字段中取值,查找到合适的值时就会⾃动分页。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
*/
public void lastPage();
/**
* 返回总的记录数
*/
public long getNrOfElements();
/** * 返回在当前页面 Nhomakorabea的第一个记录在所有记录(从0开始)中的编号
改进Spring中的分页技术
Spring中有一个PagedListHolder,可以实现分页。但此类有几个缺点:
1. 使用此类的代码比较繁琐
2. 此类存放的数据源是所有的记录集,即对于记录数为1000条的数据,即使我们只需在一个页面中显示10条记录,每次均需要检索1000条记录出来,并且没有内在的缓存机制
*/
public int getFirstElementOnPage();
/**
* 返回在当前页面上的最后一个记录在所有记录(从0开始)中的编号
*/
public int getLastElementOnPage();
public static final int DEFAULT_PAGE_SIZE = 10;
public static final int DEFAULT_MAX_LINKED_PAGES = 10;
public void setRecordsSubst(List recordsSubset);
public void setRealRecordCount(long realRecordCount);
/**
* 设置每页应有多少条记录。
*/
public void setPageSize(int pageSize);
/**
nextPage();
} else if (pageNavAction.equals("lastPage")) {
lastPage();
}
}
}
firstPage();
} else if (pageNavAction.equals("previousPage")) {
previousPage();
} else if (pageNavAction.equals("nextPage")) {
/**
* 返回在当前页面上的所有记录
*/
public List getPageList();
}
setRecordsSubst()用于存放页面显示的记录源,而setRealRecordCount()用于记录满足条件的记录总数。
下面是此接口的实现:
public RequestPagedListHolder(HttpServletRequest request, long realRecordCount, PagedListProvider pagedListProvider) {
setRealRecordCount(realRecordCount);
String pageNavAction = request.getParameter("pageNavAction");
if (pageNavAction != null) {
if (pageNavAction.equals("firstPage")) {
setRecordsSubst(pagedListProvider.getRecordsSubset(getPageSize() * getPage(), getPageSize()));
}
private void checkPageNavigation(final HttpServletRequest request) {
* 返回每页共有多少条记录
*/
public int getPageSize();
/**
* 根据pageSize,返回共有多少页
*/
public int getPageCount();
/**
* 返回当前页码。
* 如果已经是最后一页,则停在该页。
*/
public void nextPage();
/**
* 转至首页。
*/
public void firstPage();
/**
* 转至最后一页
* 此方法<strong>会</strong>影响getFirstLinkedPage()及getLastLinkedPage()
*/
public void setMaxLinkedPages(int maxLinkedPages);
/**
* 返回围绕当前页最多可以显示多少链接的页数
package com.sarkuya.web.pagination;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.ServletRequestDataBinder;
3. 如果需将pageSize, maxLinkedPages这些一般为Session级的变量存于Session中,则必须在Session中存放PagedListHolder,从而导致大容量的数据常常撑满了Session
4. 只是实现了Serializable标识接口,且getPage(), setPage(), setPageSize()方法中直接使用newPageSet (private) 的属性,不利于子类覆盖。而且,内部类的各个方法耦合极强。特定方法的使用必须信赖于某个方法或标志变量作为前提条件。
/**
*
* @author Sarkuya
*/
public class RequestPagedListHolder implements PagedListHolder {
private static int pageSize = DEFAULT_PAGE_SIZE;
private static int maxLinkedPages = DEFAULT_MAX_LINKED_PAGES;
}
public int getPage() {
if (page >= getPageCount()) {
page = getPageCount() - 1;
}
return page;
}
this.realRecordCount = realRecordCount;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getPageSize() {
return pageSize;
}
public int getPageCount() {
float nrOfPages = (float) getNrOfElements() / getPageSize();
return (int) ((nrOfPages > (int) nrOfPages || nrOfPages == 0.0) ? nrOfPages + 1 : nrOfPages);
private int page = 0;
private List recordsSubset;
private long realRecordCount;
/** Creates a new instance of RequestPagedListHolder */
* 首页为0
*/
public int getPage();
/**
* 设置当前页码。
* 首页为0
*/
public void setPage(int page);
/**
* 设置围绕当前页最多可以显示多少链接的页数。
*/
public int getMaxLinkedPages();
/**
* 返回首页的页码
*/
public int getFirstLinkedPage();
/**
* 返回最后一页的页码
*/
下面是抽取出来的PagedListHolder接口。
package com.sarkuya.web.pagination;
import java.io.Serializable;
import java.util.List;
/**
*
* @author Sarkuya
*/
public interface PagedListHolder extends Serializable {
比较理想的情况是,根据每一个HttpServletRequest产生一个PagesListHolder,不管记录总数有多少个,每次只检索页面上所显示的记录,但将pageSize, maxLinkedPages设为Session级的效果。
鉴于上述几点,我从Spring原有的PagedListHolder抽取出一些必需的方法名作为接口,并以一个名为RequestPagedListHolder的类实现之。
public void setRecordsSubst(List recordsSubset) {
this.recordsSubset = recordsSubset;
}
public void setRealRecordCount(long realRecordCount) {
相关文档
最新文档