精华内容
下载资源
问答
  • 分页查询抽象
    热门讨论
    2015-09-27 16:45:55

           OA视频和SSH网上商城最大的区别是什么,不是项目的不同,是面向的对象的体现不同,最近在做一个关于OA分页的抽象功能,我下面只来进行最终版的编写。

    分页,这项功能在每个页面可能都会体现到,如果每个页面都有,那好我们就把分页这部分抽象,看下面代码

    页面:

    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
    <%@ taglib prefix="s" uri="/struts-tags" %>
    
    <div id=PageSelectorBar>
    	<div id=PageSelectorMemo>
    		页次:${currentPage}/${pageCount }页  
    		每页显示:${pageSize }条  
    		总记录数:${recordCount }条
    	</div>
    	<div id=PageSelectorSelectorArea>
    	
    		<a href="javascript: gotoPage(1)" title="首页" style="cursor: hand;">
    			<img src="${pageContext.request.contextPath}/style/blue/images/pageSelector/firstPage.png"/>
    		</a>
    		
    		<s:iterator begin="%{beginPageIndex}" end="%{endPageIndex}" var="num">
    			<s:if test="#num == currentPage"> <%-- 当前页 --%>
    				<span class="PageSelectorNum PageSelectorSelected">${num}</span>
    			</s:if>
    			<s:else> <%-- 非当前页 --%>
    				<span class="PageSelectorNum" style="cursor: hand;" onClick="gotoPage(${num});">${num}</span>
    			</s:else>
    			
    		</s:iterator>
    		
    		<a href="javascript: gotoPage(${pageCount})" title="尾页" style="cursor: hand;">
    			<img src="${pageContext.request.contextPath}/style/blue/images/pageSelector/lastPage.png"/>
    		</a>
    		
    		转到:
    		<select οnchange="gotoPage(this.value)" id="_pn">
    			<s:iterator begin="1" end="%{pageCount}" var="num">
    				<option value="${num}">${num}</option>
    			</s:iterator>
    		</select>
    		<script type="text/javascript">
    			$("#_pn").val("${currentPage}");
    		</script>
    		
    	</div>
    </div>
    
    
    <script type="text/javascript">
    	function gotoPage( pageNum ){
    		// window.location.href = "forum_show.action?id=${id}&pageNum=" + pageNum;
    		
    		$(document.forms[0]).append("<input type='hidden' name='pageNum' value='" + pageNum +"'>");
    		document.forms[0].submit();
    	}
    </script>
    

    这样我们在有分页的页面中只需写这样的一段代码就搞定了。

    <!--分页信息-->
    <%@ include file="/WEB-INF/jsp/public/pageView.jspf" %>
    

    我们来思考这么一个问题,当看SSH网上商城的时候,是不是每一个页面都会进行到计算,因为计算你数据库中数据有多少,每页显示多少条,从第几页开始显示等等,网上商城每条线都要计算一次,出现大量重复性的代码,那好,我们继续抽象,看下面代码:

    PageBean代码:

    package cn.itcast.oa.domain;
    
    import java.util.List;
    
    /**
     * 分页功能中的一页的信息
     * 
     * @author 志鹏
     * 
     */
    public class PageBean {
    
    	// 指定的或是页面参数
    	private int currentPage; // 当前页
    	private int pageSize; // 每页显示多少条
    
    	// 查询数据库
    	private int recordCount; // 总记录数
    	private List recordList; // 本页的数据列表
    
    	// 计算
    	private int pageCount; // 总页数
    	private int beginPageIndex; // 页码列表的开始索引(包含)
    	private int endPageIndex; // 页码列表的结束索引(包含)
    
    	/**
    	 * 只接受前4个必要的属性,会自动的计算出其他3个属生的值
    	 * 
    	 * @param currentPage
    	 * @param pageSize
    	 * @param recordCount
    	 * @param recordList
    	 */
    	public PageBean(int currentPage, int pageSize, int recordCount, List recordList) {
    		this.currentPage = currentPage;
    		this.pageSize = pageSize;
    		this.recordCount = recordCount;
    		this.recordList = recordList;
    
    		// 计算总页码
    		pageCount = (recordCount + pageSize - 1) / pageSize;
    
    		// 计算 beginPageIndex 和 endPageIndex
    		// >> 总页数不多于10页,则全部显示
    		if (pageCount <= 10) {
    			beginPageIndex = 1;
    			endPageIndex = pageCount;
    		}
    		// >> 总页数多于10页,则显示当前页附近的共10个页码
    		else {
    			// 当前页附近的共10个页码(前4个 + 当前页 + 后5个)
    			beginPageIndex = currentPage - 4;
    			endPageIndex = currentPage + 5;
    			// 当前面的页码不足4个时,则显示前10个页码
    			if (beginPageIndex < 1) {
    				beginPageIndex = 1;
    				endPageIndex = 10;
    			}
    			// 当后面的页码不足5个时,则显示后10个页码
    			if (endPageIndex > pageCount) {
    				endPageIndex = pageCount;
    				beginPageIndex = pageCount - 10 + 1;
    			}
    		}
    	}
    }
    
    上面代码中的一些get set方法我删除了,看到上面这个类中的方法和业务逻辑其实并不难,但是如果重复性的工作多了,这些东西也是够折磨你的。

    由于篇幅过长 小编在下篇文章中 继续为您抽象!



    更多相关内容
  • 分页查询抽象出的对象

    这里写图片描述
    分页查询抽象出的对象

    展开全文
  • Spring Data JPA 使用JpaSpecificationExecutor实现多条件查询分页查询和非分页查询) 然后发现还有其他两种写法,会更简便一些。 1、使用JPA自带的findByXxx接口 示例: default方法 在java8以后,接口中可以添加...

    之前写过一篇博客
    Spring Data JPA 使用JpaSpecificationExecutor实现多条件查询(分页查询和非分页查询)

    然后发现还有其他两种写法,会更简便一些。

    1、使用JPA自带的findByXxx接口
    这种方法其实还比较方便,除了如果字段多的话findByXxx这个方法的名字会很长很长很长…
    Containing的用法与like一致.

    示例:
    顺便说明一下default方法:
    在java8以后,接口中可以添加使用default或者static修饰的方法,在这里我们只讨论default方法,default修饰方法只能在接口中使用,在接口中被default标记的方法为普通方法,可以直接写方法体。
    实现类会继承接口中的default方法。

    @Repository
    public interface UserRepository extends JpaRepository<UserDO,Long> {
    
        Page<UserDO> findByUsernameContainingAndUserPasswordContaining(String username, String password, Pageable pageable);
    
        default Page<UserDO> searchUserByCondition(String username, String password, Pageable pageable){
            if(username == null){
                username = "";
            }
            if(password == null){
                password = "";
            }
            return findByUsernameContainingAndUserPasswordContaining(username, password, pageable);
        }
    
    }
    

    写个类测试一下:
    注意要加上注解@RunWith(SpringRunner.class),有了这个注解@Autowired注入的类才能实例化到spring容器中,自动注入才能生效,如果不加这一行会报错NullPointerExecption.

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserTest {
    
        @Autowired
        private UserRepository userRepository;
    
        @Test
        public void Test1(){
            UserDO userDO = new UserDO();
            userDO.setUsername("yogi");
            userDO.setUserPassword("123456");
            userRepository.saveAndFlush(userDO);
    
            List<UserDO> userDOList = userRepository.searchUserByCondition("yog",null, PageRequest.of(0,10)).getContent();
    
            System.out.println(userDOList.size());
        }
    
    }
    

    2、使用ExampleMatcher

    @Repository
    public interface UserRepository extends JpaRepository<UserDO,Long> {
    
        default Page<UserDO> searchUserByCondition2(UserDO userDO, Pageable pageable){
            if (StringUtils.isEmpty(userDO.getUserPassword())) {
                // 对于数据库中允许为空的字段,需要设置null值,否则传入双引号会被判断成有值
                userDO.setUserPassword(null);
            }
            ExampleMatcher matcher = ExampleMatcher.matching()
                    .withIgnoreNullValues()
                    .withIgnoreCase(false)
                    .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.contains())
                    .withMatcher("userPassword", ExampleMatcher.GenericPropertyMatchers.contains())
                    .withIgnorePaths("userId", "userPhone");//忽略属性
            Example<UserDO> userDOExample = Example.of(userDO, matcher);
            return this.findAll(userDOExample,pageable);
        }
    
    }
    

    方法如下:

    方法含义
    caseSensitive()大小写敏感
    ignoreCase()忽略大小写
    contains()模糊匹配,%{str}%
    startsWith()匹配起始字符串,{str}%
    endsWith()匹配结尾字符串,%{str}
    exact()精确匹配字符串
    reges()将字符串作为正则表达式进行匹配

    注意一下当使用完全匹配.exact()时,参数为String类型时,传参时如果传""(空字符串),并不是不进行筛选,而是会筛选"",结果极有可能查询结果为空。
    要解决这个问题,也可以在之前对需要完全匹配的属性做出如下设置:

    if (StringUtils.isEmpty(userDO.getXxx())) {
        userDO.setXxx(null);
    }
    

    此时该属性需要完全匹配,并当传入""时会不进行筛选,而是查出全部。

    展开全文
  • SpringBoot分页查询

    2022-07-20 16:54:51
    **表示抽象查询的行为,该查询将获得一个List集合**/}

    一. spring boot简介

    springboot特点:基于编程式和注解式配置,习惯(约定)优于配置。

    springboot优势:

    ①:springboot让配置更简单

    springboot推出了starter组件,即自动配置器,我们只需要在应用中引入相关组件的starter即可完成配置,从spring应用中复杂而繁琐的配置中解脱出来,实现项目的快速搭建。

    springboot官方提供的starter命名格式为spring-boot-starter-×××

    第三方提供的starter命名格式为×××-spring-boot-starter

    ②:springboot让开发更简单

    springboot支持内嵌容器,如tomcat,jetty,应用自带服务器,直接启动应用即可,无需额外安装服务器。

    springboot提供了强大的开发工具包,支持热启动。

    ③:springboot让测试更简单

    springboot内置了常用的测试框架,仅需引入一个spring-boot-starter-test依赖包,即可进行各种测试

    ④:springboot让部署更加简单

    springboot应用默认打包jar包

    ⑤:springboot让监控更简单

    springboot就是一款自带监控的框架,专门提供了监控组件来完成这个工作。

    眺望springcloud:

    spring为应对互联网应用的要求(高可靠,高并发,能够负载均衡等),基于springboot推出了微服务框架springcloud,因此springcloud完全建立在springboot之上。

    二. 开发一个springboot应用,引入依赖

     <!--引入springboot父项目:该父项目中内置了很多习惯性配置和jar版本号之间的关联-->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.6.4</version>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.6.4</version><!--此处版本号可以省略,因为springboot父项目中已经内置配置好了-->
            </dependency>
            <!--引入springboot开发工具包,可以支持热启动-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
            <!-- 引入mybatis的starter -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.1</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.27</version>
            </dependency>
            <!--引入springboot测试支持-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <!-- pagehelper-spring-boot-starter -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>1.4.1</version>
            </dependency>
    
        </dependencies>
    
        <!--引入springboot构建插件,用于打包生成可执行jar文件-->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.6.4</version>
                </plugin>
            </plugins>
        </build>

    parent:spring-boot-starter-parent:引入springboot父项目:该父项目中内置了很多习惯性配置和jar版本号之间的关联

    dependencies:

    ①:spring-boot-starter-web:web组件

    ②:spring-boot-devtools:引入springboot开发工具包,可以支持热启动

    ③:mybatis-spring-boot-starter

    ④:mysql-connector-java

    ⑤:spring-boot-starter-test:springboot测试组件

    ⑥:pagehelper-spring-boot-starter:分页组件

    build:

    spring-boot-maven-plugin:引入springboot构建插件,用于打包生成可执行jar文件

    三. 开发springboot启动类

    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    //说明本应用为springboot应用,
    // 而且还说明这是一个springboot的启动类,同时还说明这是一个配置类
    //而且还是一个自动配置类
    
    //主类所在的包,就是springboot应用的根包
    //在springboot应用中,一般所有的组件如:controller,service,和dao等对象都应该在应用根包下或其子包下
    
    @SpringBootApplication
    //自动扫描映射器,并放入spring容器
    @MapperScan("org.xupt.ygq.demo.dao")
    public class MyApp {
        public static void main(String[] args) {
            //该语句为springboot应用的启动语句
            SpringApplication.run(MyApp.class,args);
        }
    }

    两个注解:

    ①:@SpringBootApplication:

    说明本应用为springboot应用,而且还说明这是一个springboot的启动类,同时还说明这是一个配置类。

    主类所在的包,就是springboot应用的根包,在springboot应用中,一般所有的组件如:controller,service,和dao,等对象都应该在应用根包或者根包的子包下面

    ②:@MapperScan:自动扫描映射器(也就是dao包),并存放在spring容器中

    一条语句:

    SpringApplication.run(MyApp.class,args);启动语句!!!

    四. 配置application.properties资源文件

    #配置内置服务器端口号,默认为8080
    server.port=9999
    #配置根日志的输出级别,默认为info
    logging.level.root=info
    #配置org.xupt.ygq.demo.dao包下的日志输出级别为trace,可以打印mybatis映射器执行结果
    logging.level.org.xupt.ygq.demo.dao=trace
    logging.level.org.xupt.ygq.demo=debug
    #配置springmvc的日志
    logging.level.web=trace
    #配置数据源
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/wddb
    spring.datasource.username=root
    spring.datasource.password=123456
    
    #配置mybatis
    
    #配置映射文件位置,在类路径下,mapper目录下的任意层级文件夹下的以.xml结尾的文件
    mybatis.mapper-locations=classpath:mapper/**/*.xml
    
    #pagehelper
    #配置方言,即配置使用哪一个数据库
    pagehelper.helper-dialect=mysql
    #分页的合理化配置,即如果请求页码不合理时,自动合理化,比如:请求-9页,自动合理化成第一页
    pagehelper.reasonable=true

    五.因为要做分页查询,封装分页

     5.1 分页类

    import java.util.List;
    
    public class Page<T> {
        //当前页
        private Integer current;
        //首页
        private Integer first;
        //上页
        private Integer pre;
        //下页
        private Integer next;
        //尾页
        private Integer last;
    
    
        //每页最大记录数
        private Integer pageSize;
        //总记录数
        private Long total;
        //总页数
        private Integer pages;
        //当前页实际记录数
        private Integer currSize;
    
    
        //当前页数据记录
        private List<T> list;
    
        public Integer getCurrent() {
            return current;
        }
    
        public void setCurrent(Integer current) {
            this.current = current;
        }
    
        public Integer getFirst() {
            return first;
        }
    
        public void setFirst(Integer first) {
            this.first = first;
        }
    
        public Integer getPre() {
            return pre;
        }
    
        public void setPre(Integer pre) {
            this.pre = pre;
        }
    
        public Integer getNext() {
            return next;
        }
    
        public void setNext(Integer next) {
            this.next = next;
        }
    
        public Integer getLast() {
            return last;
        }
    
        public void setLast(Integer last) {
            this.last = last;
        }
    
        public Integer getPageSize() {
            return pageSize;
        }
    
        public void setPageSize(Integer pageSize) {
            this.pageSize = pageSize;
        }
    
        public Long getTotal() {
            return total;
        }
    
        public void setTotal(Long total) {
            this.total = total;
        }
    
        public Integer getPages() {
            return pages;
        }
    
        public void setPages(Integer pages) {
            this.pages = pages;
        }
    
        public Integer getCurrSize() {
            return currSize;
        }
    
        public void setCurrSize(Integer currSize) {
            this.currSize = currSize;
        }
    
        public List<T> getList() {
            return list;
        }
    
        public void setList(List<T> list) {
            this.list = list;
        }
    
        @Override
        public String toString() {
            return "Page{" +
                    "current=" + current +
                    ", first=" + first +
                    ", pre=" + pre +
                    ", next=" + next +
                    ", last=" + last +
                    ", pageSize=" + pageSize +
                    ", total=" + total +
                    ", pages=" + pages +
                    ", currSize=" + currSize +
                    ", list=" + list +
                    '}';
        }
    }

    类定义成泛型的:因为查询到的结果list,里面装的对象是什么,是不确定的。

    5.2 分页参数

    public class PageParam {
    
        private Integer pageNum=1;//请求页码
        private Integer pageSize=5;//每页最大记录数
    
        public Integer getPageNum() {
            return pageNum;
        }
    
        public void setPageNum(Integer pageNum) {
            this.pageNum = pageNum;
        }
    
        public Integer getPageSize() {
            return pageSize;
        }
    
        public void setPageSize(Integer pageSize) {
            this.pageSize = pageSize;
        }
    }

    在进行分页之前要先设置分页参数(包含两个属性,页码pageName和每页记录数pageSize)

    PageHelper.startPage(pageParam);

    5.3 分页查询api

    import com.github.pagehelper.PageHelper;
    import com.github.pagehelper.PageInfo;
    import org.xupt.ygq.demo.common.page.Page;
    import org.xupt.ygq.demo.common.page.PageParam;
    import org.xupt.ygq.demo.common.page.QueryAction;
    import java.util.List;
    
    public class Utils {
        public static <T> Page<T> getPage(PageParam pageParam, QueryAction<T> queryAction){
            //在查询之前设置分页参数,再执行查询和设置分页参数之间不能有其他的查询。
            //该方法用于设置分页参数对象(含有页码pageName和每页记录数pageSize两个属性)
            PageHelper.startPage(pageParam);
            List<T> list = queryAction.executeQuery();//执行一个查询,获得List集合
            //紧挨在查询之后构造分页信息对象
            PageInfo<T> pageInfo = new PageInfo<>(list);
            Page<T> page = new Page<>();
            page.setCurrent(pageInfo.getPageNum());//当前页
            page.setFirst(1);//首页
            page.setPre(pageInfo.getPrePage());//上一页
            page.setNext(pageInfo.getNextPage());//下一页
            page.setLast(pageInfo.getPages());//最后一页
            page.setPageSize(pageInfo.getPageSize());//每页最大记录数
            page.setTotal(pageInfo.getTotal());//总记录数
            page.setPages(pageInfo.getPages());//总页数
            page.setCurrSize(pageInfo.getSize());//当前页实际记录数
            page.setList(pageInfo.getList());//当前页数据记录
            return page;
        }
    }
    

    定义一个泛型生成分页对象的泛型类:(两个参数)

    ①:PageParame:声明分页参数,

    ②:QueryAction:一个查询行为的接口,表示要进行分页的查询行为

    其中要注意分页信息对象:PageInfo:我们对于自己的分页对象的设置基于分页信息对象

    最后返回一个分页对象:

    5.4 定义抽象的查询行为

    import java.util.List;
    /*
    * 表示抽象的查询的行为,该查询将获得一个List集合
    * */
    
    public interface QueryAction<T> {
        public List<T> executeQuery();
    }

    5.5 封装返回结果

    public class Result<T> {
        public static final int CODE_OK = 200;
        public static final int CODE_ERR_BUSINESS = 500;
        public static final int CODE_ERR_SYS = 530;
        public static final int CODE_ERR_UNLOGINED = 520;
    
        public static <T>Result<T> ok(){
            return new Result(true,CODE_OK,null,null);
        }
        public static <T>Result<T> ok(String message){
            return new Result(true,CODE_OK,message,null);
        }
        public static <T>Result<T> ok(T data){
            return new Result(true,CODE_OK,null,data);
        }
        public static <T>Result<T> ok(String message,T data){
            return new Result(true,CODE_OK,message,data);
        }
    
        public static <T>Result<T> err(int errCode ,String message){
            return new Result(false,errCode,message,null);
        }
        public static <T>Result<T> err(int errCode ,String message,T data){
            return new Result(false,errCode,message,data);
        }
    
        private boolean success;//是否成功
        private int code;//200 成功 500 业务失败,530 系统错误,520 未登录
        private String message;//概要信息
        private T data;
    
        public Result(boolean success, int code, String message, T data) {
            this.success = success;
            this.code = code;
            this.message = message;
            this.data = data;
        }
    
        public boolean isSuccess() {
            return success;
        }
    
        public int getCode() {
            return code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public T getData() {
            return data;
        }
    }

    六. 开发model和dto

    import com.fasterxml.jackson.annotation.JsonFormat;
    
    import java.util.Date;
    
    public class Employee {
        private String e_id;
        private Integer d_id;//部门编号
        private Integer e_sex;
        private String e_name;
        private Date e_birth;
    
        public String getE_id() {
            return e_id;
        }
    
        public void setE_id(String e_id) {
            this.e_id = e_id;
        }
    
        public Integer getD_id() {
            return d_id;
        }
    
        public void setD_id(Integer d_id) {
            this.d_id = d_id;
        }
    
        public Integer getE_sex() {
            return e_sex;
        }
    
        public void setE_sex(Integer e_sex) {
            this.e_sex = e_sex;
        }
    
        public String getE_name() {
            return e_name;
        }
    
        public void setE_name(String e_name) {
            this.e_name = e_name;
        }
        //声明生成json的时间格式和时区
        @JsonFormat(pattern = "yyyy-MM-dd",timezone = "GMT=8")
        public Date getE_birth() {
            return e_birth;
        }
    
        public void setE_birth(Date e_birth) {
            this.e_birth = e_birth;
        }
    
        @Override
        public String toString() {
            return "Employee{" +
                    "e_id='" + e_id + '\'' +
                    ", d_id=" + d_id +
                    ", e_sex=" + e_sex +
                    ", e_name='" + e_name + '\'' +
                    ", e_birth=" + e_birth +
                    '}';
        }
    }
    import java.util.Date;
    
    //表示封装查询条件的dto
    public class EmployeeQueryDto extends PageParam {
        private String e_id;
        private Integer d_id;//部门编号
        private Integer e_sex;
        private String e_name;
        private Date e_birth_start;
        private Date e_birth_end;
    
        public String getE_id() {
            return e_id;
        }
    
        public void setE_id(String e_id) {
            this.e_id = e_id;
        }
    
        public Integer getD_id() {
            return d_id;
        }
    
        public void setD_id(Integer d_id) {
            this.d_id = d_id;
        }
    
        public Integer getE_sex() {
            return e_sex;
        }
    
        public void setE_sex(Integer e_sex) {
            this.e_sex = e_sex;
        }
    
        public String getE_name() {
            return e_name;
        }
    
        public void setE_name(String e_name) {
            this.e_name = e_name;
        }
        @DateTimeFormat(pattern = "yyyy-MM-dd")//对前端传来的时间格式说明
        public Date getE_birth_start() {
            return e_birth_start;
        }
    
        public void setE_birth_start(Date e_birth_start) {
            this.e_birth_start = e_birth_start;
        }
    
        public Date getE_birth_end() {
            return e_birth_end;
        }
        @DateTimeFormat(pattern = "yyyy-MM-dd")//对前端传来的时间格式说明
        public void setE_birth_end(Date e_birth_end) {
            this.e_birth_end = e_birth_end;
        }
    }
    

    dto继承了PageParam:继承了他的分页参数,方便一起从前端页面传回数据。这样子就可以把dto和分页参数融合在一起进行参数传递。

    七. 开发控制器组件

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.xupt.ygq.demo.common.Result;
    import org.xupt.ygq.demo.common.page.Page;
    import org.xupt.ygq.demo.dto.EmployeeQueryDto;
    import org.xupt.ygq.demo.model.Employee;
    import org.xupt.ygq.demo.service.EmpService;
    
    @RestController
    public class MyController {
        @Autowired
        private EmpService empService;
        @GetMapping("/emp")
        //分页查询需要分页参数,dto继承了分页参数类,所以他里面就有分页参数
        public Result empList(EmployeeQueryDto dto){
            Page<Employee> page = empService.getEmpPage(dto);
            return Result.ok(page);
        }
    }

    三个注解:

    ①:RestController

    ②:Autowired

    ③:GetMapping

    定义处理方法:传递参数

    八. 开发业务对象

    import org.xupt.ygq.demo.common.page.Page;
    import org.xupt.ygq.demo.common.page.PageParam;
    import org.xupt.ygq.demo.model.Employee;
    
    
    public interface EmpService {
        public Page<Employee> getEmpPage(PageParam pageParam);
    }

     这里为什么用PageParam接受呢,因为dto对象时PageParam的子类,所以用父类型接收。

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import org.xupt.ygq.demo.common.Utils;
    import org.xupt.ygq.demo.common.page.Page;
    import org.xupt.ygq.demo.common.page.PageParam;
    import org.xupt.ygq.demo.dao.EmpDao;
    import org.xupt.ygq.demo.model.Employee;
    import org.xupt.ygq.demo.service.EmpService;
    
    @Service//表示本对象是业务对象,并且受spring容器管理
    @Transactional//声明本业务对象的所有方法都是事务性的
    public class EmpServiceImpl implements EmpService {
        @Autowired
        private EmpDao empDao;
        /*
        * pageHelper是一个适用于MyBatis的分页插件,通过该插件可以很方便的实现分页查询
        * */
        /*@Override
        public Page<Employee> getEmpPage(PageParam pageParam) {
            QueryAction<Employee> action = new QueryAction<Employee>() {
                @Override
                public List<Employee> executeQuery() {
                    return empDao.findEmpList();
                }
            } ;
    
            return Utils.getPage(pageParam,action);
        }*/
    //    @Override
    //    public Page<Employee> getEmpPage(PageParam pageParam) {
    //        QueryAction<Employee> action =()->{
    //                return empDao.findEmpList();
    //            };
    //
    //        return Utils.getPage(pageParam,action);
    //    }
        @Override
        public Page<Employee> getEmpPage(PageParam pageParam) {
            //QueryAction<Employee> action =()-> empDao.findEmpList();
    
            return Utils.getPage(pageParam,()-> empDao.findEmpList(pageParam));
        }
    }

    实现类里面有一个重要的点:就是调用分页查询api的时候,参数QueryAction接口的实现是内部类,再加上接口中只有一个方法,所以可以简化书写

    九. 开发持久层

    import org.xupt.ygq.demo.common.page.PageParam;
    import org.xupt.ygq.demo.model.Employee;
    
    import java.util.List;
    
    public interface EmpDao {
        //@Select("select * from t_emp")
        public List<Employee> findEmpList(PageParam pageParam);
    }
    

    持久层返回的List在Service实现中被封装成了page对象。

    十. 开发mapper

    <?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="org.xupt.ygq.demo.dao.EmpDao">
        <!-- 需求: 通过给定属性 查询用户 -->
        <select id="findEmpList" resultType= "org.xupt.ygq.demo.model.Employee">
            select * from t_emp
            <where>
                <!--<include refid="sql_query_where"></include>-->
                <if test="e_id!=null and e_id!='' ">
                    and e_id like concat('%',#{e_id},'%')
                </if>
                <if test="e_name!=null and e_name!='' ">
                    and e_name like concat('%',#{e_name},'%')
                </if>
    
                <if test="e_sex!=null ">
                    and e_sex=#{e_sex}
                </if>
                <if test="d_id!=null ">
                    and d_id=#{d_id}
                </if>
    
                <if test="e_birth_start!=null  ">
                    and e_date &gt;= #{e_date_start}
                </if>
                <if test="e_birth_end!=null  ">
                    and e_date &lt;= #{e_date_end}
                </if>
            </where>
        </select>
    </mapper>

    整个分页由插件完成!!!

    mapper需要在application.properties中配置映射路径。

    还需要注意映射的包:

     

    十一. 测试 

     

    展开全文
  • 有关分页类的使用说明.zip,有关分页类的使用说明.doc
  • 2、之前做了一个需要分页、多表关联、多条件查询的需求,当时项目集成的是jpa,如果是其他比如mybatis、mybatis-plus这些那太好实现了,过于复杂如果plus不好拼,大不了直接xml写sql就行。 3、jpa的dao层一般是这样...
  • jpa分组分页查询 page计算错误解决
  • Mybatis的分页查询 作用:在查询大量数据时,使用分页进行查询,也可以说是变成处理小部分的数据,把对数据库的压力把控在可控范围 步骤: 1、添加接口抽象类 /** * 分页查询,这需要使用引用类 * @return */ ...
  • Spring Data 查询分页 -- 分页结果返回

    千次阅读 2018-11-05 12:14:16
    针对数据查询中的分页请求参数和分页结果返回,Spring 做了建模抽象并提供了相应的工具实现,这部分模型和工具包含在包spring-data-commons中,本文对其中分页结果返回部分做一下梳理,方便在开发中使用 。...
  • php_smarty分页.zip,php,smarty分页,Pagination.class.php,QQ拼音截图未命名.bmp,PageEntry.class.php,test.php,test.html
  • 在某些时候,我们调用第三方接口时,他们的接口有进行分页,但是并不能满足我们的需求。 那么我们就需要自己进行分页处理。思路一般是: 第一步:获取第三方接口调用返回的所有结果(可以循环获取),具体示例参考...
  • 一开始想对Paginator类的属性进行设置,可是发现它是个抽象类。然后 我突然想到 内置模板是怎么渲染的,总要有上一页下一页的跳转吧,然后我就把$this->render()打印了一下,是html代码,里面有url跳转,然后在官方...
  • OA-分页查询抽象最终版)二

    热门讨论 2015-09-27 17:10:50
    上篇文章我们已经把前台和工具类PageBean抽象出来了,下面我们继续抽象:  比如我们要查询板块的信息时,我们要将板块的信息,以及是否要排序和按照什么排序都要在hql语句中声明,但是我换了一个主题信息查询呢,...
  • Flask查询以及分页

    千次阅读 2019-12-19 17:36:39
    Flask查询以及分页 以动物类做例子 下面创建动物的表 class Animal(db.Model): id = db.Column(db.INTEGER, primary_key=True, autoincrement=True) a_name = db.Column(db.String(32)) a_age = db.Column(db....
  • 首先JPA规定了可以通过传入pageable对象来查询分页数据,返回类型为Page<T> Page<T>带有附加信息的Slice,例如结果的总数。需要一个Pageable方法参数。 它官网的原话是 Page<T> A ...
  • Spring Data 查询分页 -- 分页请求参数

    千次阅读 2018-11-04 12:02:45
    针对查询分页请求和分页结果的返回,Spring 提供了相应的建模抽象并提供了相应的工具实现,这部分模型和工具包含在包spring-data-commons中,本文对这些模型和工具做一下梳理,方便在开发中使用 。 分页请求参数 ...
  • 在使用Mybatis-plus自定义多表联合分页查询时遇到一些问题:输出结果中,那些一对多的纪录实际的查询结果却是一对一。比如:blog拥有List类型的属性tags,并且该blog在数据库中对应着多个tag,但是最终的查询结果却...
  • SpringBoot项目中,使用MyBatis实现多条件组合分页查询 就拿淘宝来举例,当我们想要买一个手机时,会根据手机的品牌、价格、颜色等多个条件来查询,然后再分页显示数据,此时就用到了多条件组合分页查询 1、把条件封装到...
  • Spring Data Jpa实现分页查询

    万次阅读 2017-11-24 19:01:36
    在我们平时的工作中,查询列表在我们的系统中基本随处可见,那么我们如何使用jpa进行多条件查询以及查询列表分页呢?下面我将介绍两种多条件查询方式。 1、引入起步依赖  dependency> groupId>org.spring...
  • Mongo 分页查询

    千次阅读 2016-07-28 09:41:12
    分页说明 以典型的列表api来说:下拉刷新是获取最新信息,然后上拉加载下一页 常见api要写的2个接口 get_latest(model,count)get_with_page(number,size) get_latest一般是取最新的数据,比如我们常见的...
  • 1.使用SSH集成开发 2.创建分页抽象业务包。 3.创建自定义标签(标签类PageTag和标签描述t32.tld)
  • 案例分析: ... 当查询结果过多,无法全部显示, 或全部显示页面不够清晰友好时, 需要对查询结果进行分页显示, 故得出第二个参数: "目标页页数": 目标页页数: 初始页数为1, 用户选择响应按钮时...
  • JAVA学习笔记_真假分页查询

    千次阅读 2017-08-16 21:33:52
    当要显示数据量足够大的时候,我们往往采用分页显示的处理办法。 ———————————–分页有真分页和假分页—————————————真分页: 确定要显示的数量和内容,然后每次都去数据库取出该少量数据,...
  • mongodb 分页查询替代skip的方式

    千次阅读 2017-10-17 09:45:18
    抽象一下就是:检索第n页的代码应该是这样的 db . users . find (). skip ( pagesize *( n - 1 )). limit ( pagesize ) 当然,这是假定在你在2次查询之间没有任何数据插入或删除操作,你的系统能么? ...
  • ​使用方式及代码 //查询某条记录表名ts =表名Cache.getValue(表名Cache.getEndkey(),datatype + "_" + number); //清除缓存 表名Cache.delete(null...//分页查询 List<Object> list = null; if("desc".e...
  • 分页查询输入:页码和每页的记录条数(必需)排序规则(非必需)查询条件(非必需)输出:记录集合记录总条数总页数由此可设计出两个类,分别对应分页操作的输入和输出PageReqeust:/*** Created by liur...
  • 作者:岁月安然blog.csdn.net/baidu_38083619/article/details/82463058前因项目一直使用的是PageHelper实现分页功能,项目前期数据量...
  • n实战案例:带你实现RecyclerView分页查询功能(仿照主流电商APP,可切换列表和网格效果) 随着Kotlin的推广,一些国内公司的安卓项目开发,已经从Java完全切成Kotlin了。虽然Kotlin在各类编程语言中的排名比较...
  • SpringBoot使用PageHelper实现数据分页

    千次阅读 2020-11-03 20:39:19
    我们在做页面查询的时候由于页面无法一次性展示所有的数据,所以采用一种分段式的展示策略—分页查询,实现分页查询的方式有很多种方式,比如sql中的limit,mybatisplus带的分页插件等等,这里我们介绍一下如何在...
  • /** * 分页查询 * * @param pageParam 分页查询参数 * @return 分页查询响应 */ @PostMapping(path = "page") public PageInfo page(@RequestBody PageParam pageParam) { return service.page(pageParam);...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,995
精华内容 17,198
热门标签
关键字:

分页查询抽象