• 动态sql和分页

    目录

    一、映射文件XxxMapper.xml.介绍

    二、MyBatis之mapper接口传参

    2.1增删改查标签属性-id¶meterType&resultType介绍

    2.2Mapper接口带参案例演示

    三、MyBatis之动态SQL

    四、MyBatis之模糊查询

    五、MyBatis之resultType

    六、MyBatis之resultMap

    七、MyBatis之分页插件PageHelper

    7.1PageHelper插件介绍

    7.2使用步骤

    一、映射文件XxxMapper.xml.介绍

         1.1文件作用：MyBatis里面的sql语句既可以在xxxMapper.xml文件里面定义，也可以通过注解方式定义。
        1.2编写数量：mapper包里面的每个接口对应一个Mapper映射文件，也就是一个数据库里面的每张数据表对应一个Mapper映射文件。
        1.3命名规范：Mapper映射文件的命名是把XxxMapper接口的后缀名改为是".xml"，比如：BookMapper接口对应的映射文件名是：BookMapper.xml。
        1.4文件内容介绍：
            1.4.1头部：主要是通过dtd定义和限制当前文件中可以使用的标签和属性，以及标签出现的次数及顺序。
            
            1.4.2SQL定义部分：
                1.一对标签：根标签，使用insert、update、delete、select标签编写 XxxMapper接口方法里面对应的sql语句。
                2.namespace属性：
                        命名空间，非常重要。值是当前XxxMapper.xml映射文件对应的XxxMapper接口的全限定名称，且是唯一的。
                        作用：参与识别sql语句。在mybatis中，映射文件中的namespace是用于绑定mapper接口，即面向接口编程。
                        当你的namespace绑定接口后，你可以不用写接口实现类，
                        mybatis会通过该绑定自动、帮你找到对应要执行的SQL语句。

    二、MyBatis之mapper接口传参

    2.1增删改查标签属性-id¶meterType&resultType介绍

            2.1.1属性-id：id属性的值是xxxMapper接口里面的方法名。
            
            2.1.2属性-parameterType：parameterType属性表示Mapper接口方法所带参数的类型，可以使用数据类型的完全限定名或者别名(系统指定好的)。这个属性是可省略的，因为 MyBatis 可以推断出具体传入sql语句的参数的数据类型。
                MyBatis默认支持的别名如下所示(部分)：
                    Double --> double;    Float --> float；
                    Boolean --> boolean;    Date --> date;
                    String  --> string;    
                    boolean --> _boolean;    byte --> _byte;
                    long    --> _long;      int  --> _int;
                    float   --> _float    ......
            
            2.1.3属性-resultType：resultType属性表示Mapper接口方法的返回值类型，使用返回值类型的完全限定名。

    1.简单参数返回类型：八大基本数据类型 + String

    2.实体类型

    List

    例：List

    resultType="Book"

    Map

    例：Map和List>

    resultType="java.util.Map"
        


    2.2Mapper接口带参案例演示

    2.2.1带一个简单类型参数：通过id查询书本。
                简单类型指的是：java 八大基本类型和String类型；
                xxxMapper.xml文件的sql语句中，通过占位符 #{任意字符 }(自定义任意字符，和接口方法的参数名可以不同)获取接口方法里面传入的参数值。

     示例：

    Mapper接口

    Book selectByPrimaryKey(Integer bookId);

    BookMapper.xml

    1. <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book
    5.     where book_id = #{bookId,jdbcType=INTEGER}
    6. select>

    junit测试

    1. @Test
    2. public void selectByPrimaryKey() {
    3.     book.setBookId(123);
    4.     System.out.println(bookServiceImpl.selectByPrimaryKey(book.getBookId()));
    5. }
     

      2.2.2带多个简单类型参数-使用@Param注解
                 @Param注解是MyBatis提供的。
                 当Mapper 接口中的方法带多个参数的时候要通过@Param注解给参数取别名(必须，而且别名可以和形参名保持一致)，在xxxMapper.xml文件的sql语句中需要通过参数别名使用参数。
     

     

    示例（查询id或者名字查询书本）：
     

     BookMapper接口
     

    List selectIdOrName2(@Param("myBookId") Integer bookId,@Param("myBookName") String bookName);
     

    BookMapper.xml
     

     

    junit测试
     

    1. @Test
    2. public void testSelectIdOrName2() {
    3.     List<Book> books = bookServiceImpl.selectIdOrName2(124, null);
    4.     books.forEach(System.out::println);
    5. }
     

            
2.2.3带多个简单类型参数-使用Java对象.
            当Mapper接口里面的方法带的参数过多的时候，
            用@Param注解取别名的方式就会显的有点繁琐，
            所以我们推荐使用Java对象传参。
            使用java 对象传递参数，java 的属性值就是 sql 需要的参数值，每一个属性就是一个参数。
            在XxxMapper.xml里面通过 #{} 获取的参数名必须和实体类的属性名保持一致(底层是通过调用属性的get方法获取属性值)。

     

    示例：
     

     BookMapper接口
     

    int updateByPrimaryKey(Book record);
     

    BookMapper.xml
     

    1. id="updateByPrimaryKey" parameterType="com.zking.model.Book">
    2.     update t_book
    3.     set book_name        = #{bookName,jdbcType=VARCHAR},
    4.         book_name_pinyin = #{bookNamePinyin,jdbcType=VARCHAR},
    5.         book_price       = #{bookPrice,jdbcType=REAL},
    6.         book_type        = #{bookType,jdbcType=INTEGER}
    7.     where book_id = #{bookId,jdbcType=INTEGER}
     

    junit测试
     

    1. @Test
    2. public void updateByPrimaryKey() {
    3.     bookServiceImpl.updateByPrimaryKey(
    4.             Book.builder()
    5.                     .bookName("乐媛")
    6.                     .bookNamePinyin("LY")
    7.                     .bookPrice(3f)
    8.                     .bookType(1)
    9.                     .bookId(1)
    10.                     .build());
    11. }
     

    【了解】2.2.4带多个参数-按位置获取.通过书本id或者名称查询书本。
        根据Mapper接口中方法的形参列表，从左往右，参数位置分别是：0，1，2，3....
        mybatis-3.3 版本和之前的版本使用#{0},#{1}方式， 从mybatis3.4 开始使用#{arg0}方式。所以在使用该方式传参的时候注意选择MyBatis的版本。
            在xxxMapper.xml文件中引用参数语法：#{ arg参数位置}，如：第一个参数是#{arg0}, 第二个是#{arg1}。如：
                  select .... where id = #{arg1} or name = #{arg0};

     

     

    2.2.5带多个参数-使用Map[万能&推荐]：
     

    把Map集合当做Mapper接口中方法的参数，也就是首先把所有参数放到Map集合里面，然后再把Map集合当做参数传入Mapper接口的方法中；
     

     

     示例：
     

    BookMapper接口
     

    List<Book> query(Map<String,Object> map);
     

    BookMapper.xml
     

    1. <select id="query" resultType="com.zking.model.Book" resultMap="BaseResultMap">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book
    5.     where book_id = #{arg0,jdbcType=INTEGER} or book_name = #{arg1,jdbcType=VARCHAR}
    6. select>
     

    junit测试
     

    1. @Test
    2. public void query() {
    3.     Map<String,Object> map = new HashMap<>();
    4.     map.put("arg0",0);
    5.     map.put("arg1","格林童话");
    6.  
    7.     System.out.println(bookServiceImpl.query(map));
    8. }
     

    控制台打印：
     

     

     

     

     

     

    三、MyBatis之动态SQL
     

    3.1.MyBatis动态SQL概述.
             1).动态SQL，通过MyBatis 提供的各种标签对条件作出判断以实现动态拼接SQL 语句，
                 主要是where部分有变化。
             2).常用的动态SQL 标签有、、、等。
             3).MyBatis 的动态SQL 语句，与JSTL标签中的语句非常相似。
             4).动态 SQL应用场景：
                 主要用于解决查询条件不确定的情况。
                 在程序运行期间，根据用户提交的查询条件进行查询。
                 提交的查询条件不同，执行的 SQL 语句不同。
                 若将每种可能的情况都由程序员逐一列出，
                 对所有条件进行排列组合，将会出现大量的SQL 语句。
                 此时，可使用动态 SQL 来解决这样的问题。
             5).注意，动态sql的sql语句部分可以使用 ">"和">="，但是不能使用 "<"和"<="，要使用 "<" 表示 "<"，"<="表示 "<="（验证：查询指定价格范围内的数据）。> >
     

     

     

    3.2.动态SQL之+ 
     

    示例：
     

    BookMapper接口
     

    List selectIdOrName2(@Param("myBookId") Integer bookId,@Param("myBookName") String bookName);
     

    BookMapper.xml
     

     

    junit测试
     

    1. @Test
    2. public void testSelectIdOrName2() {
    3.     List<Book> books = bookServiceImpl.selectIdOrName2(1, "ha");
    4.     books.forEach(System.out::println);
    5. }
     

     


    3.3动态sql之trim
             属性：
             prefix：要添加的前缀；prefixOverrides：要删除的前缀。
             suffix：要添加的后缀；suffixOverrides：要删除的后缀。
             insert方法分析。
     

    示例：
     

    
  insert into t_book
  prefix="(" suffix=")" suffixOverrides="," >
    
      book_id,
    
    
      book_name,
    
    
      book_name_pinyin,
    
    
      book_price,
    
    
      book_type,
    
  
  prefix="values (" suffix=")" suffixOverrides="," >
    
      #{bookId,jdbcType=INTEGER},
    
    
      #{bookName,jdbcType=VARCHAR},
    
    
      #{bookNamePinyin,jdbcType=VARCHAR},
    
    
      #{bookPrice,jdbcType=REAL},
    
    
      #{bookType,jdbcType=INTEGER},
    
  

     

     

     

    3.4动态SQL之
             属性–collection：表示要遍历的类型是数组还是List集合。
                     如果Mapper接口方法里面的形参是数组，
                     那么collection="array"；
                     如果Mapper接口方法里面的形参是List集合，
                     那么collection="List"；
             属性–open、close、separator：对遍历list集合的内容进行拼接，如：
                 collection里面的数组或者集合其实就是sql条件查询里面条件的取值范围，
                 比如：where sid in(1,2,3,4,5)，那么collection里面的数组或者集合表示的就是 "1 2 3 4 5"，
                 注意值和值之间是没有符合隔开的，而且开始和末尾也没有小括号包裹。
                 在sql语句执行的时候这些取值要用括号括起来，而且值和值之间一般要用逗号隔开。
                 open、close、separator这三个属性就是完成这些工作的，比如：sql语句where sid in(1,2,3,4,5)，
                 那么：open="("，separator=","，close=")"。
             属性–item：表示要遍历的list集合里面的每条数据，在当前案例里面list集合里面存放的是学号，那么item表示的就是每个学号。
             语法：
                   
                     #{取item里面的值}
                   
     


    示例：给定一个存储书本编号的List集合，查询出书本编号在这个List集合范围的所有书本。BookMapper接口
     

    List<Book> selectBookIds(List<Integer> bookIdList);
     

    BookMapper.xml
     

    1. <select id="selectBookIds" resultType="com.zking.model.Book" resultMap="BaseResultMap">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book where true
    5.     <if test="null != list and list.size > 0">
    6.         and book_id in
    7.         <foreach item="bookIdList" collection="list" open="(" separator="," close=")">
    8.             #{bookIdList}
    9.         foreach>
    10.     if>
    11. select>
     

    junit测试
     

    1. @Test
    2.     public void selectBookIds() {
    3.         // 1.查询所有书本（没有查询书本编号）
    4.         List<Integer> integerList = new ArrayList<>();
    5. //        integerList.add(1);
    6. //        integerList.add(2);
    7.         List books = bookServiceImpl.selectBookIds(integerList);
    8.  
    9.         // 2.查询书本编号在这个List集合范围的所有书本
    10.         // Arrays.asList()把一个数组转换成一个集合
    11. //        List books = bookServiceImpl.selectBookIds(Arrays.asList(1, 2, 3, 4, 5));
    12.  
    13.         books.forEach(System.out::println);
    14.     }
     

    3.5动态SQL之
3.5.1介绍.
       1.标签是用来定义SQL片段，其实就是一段sql代码，可以是表名，几个字段，where条件都可以。
       2.可以在其他地方引用sql标签的内容，当引用sql片断时，需要通过子标签指定要引用的sql片段的id进行引用。
        3.标签可以定义在sql语句中的任何合理位置，所以子标签可以放在动态sql的任何位置。

     

    示例： 
     

    sql片段
     

    1. <sql id="Base_Column_List">
    2.     book_id
    3.     , book_name, book_name_pinyin, book_price, book_type
    4. sql>
     

    使用incluse指定引入sql片段

     

    1. <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book
    5.     where book_id = #{bookId,jdbcType=INTEGER}
    6. select>
     

     

     

     

     

    四、MyBatis之模糊查询
     

    4.1模糊查询写法一：$.
             $不会在值的前后加单引号，需要我们手动写单引号和百分号（不建议使用该方式，有SQL注入风险）。
                 如：select .... from tb_book where bookname like '%${bookname}%'
     


         4.2模糊查询写法二：#.
             #会在字符串类型值的前后添加一个单引号，但是自动加了单引号，那么百分号我们就不好加了，所以我们要通过mysql的一个内置函数concat来解决百分号的问题。
                 如：select .... from tb_book where bookname like concat('%',#{bookname},'%')
     

     

    示例（糊查询写法二）：
     

    BookMapper接口
     

    List<Book> mhQuerys(Book book);
     

    BookMapper.xml
     

    1. <select id="mhQuerys" resultType="com.zking.model.Book" resultMap="BaseResultMap">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book where 1 = 1
    5.     <if test="null != bookName and '' != bookName">
    6.         and book_name like concat('%',#{bookName},'%')
    7.     if>
    8. select>
     

    junit测试
     

    1. @Test
    2. public void mhQuerys(){
    3.     book.setBookName("周");
    4.     for (Book mhQuery : bookServiceImpl.mhQuerys(book)) {
    5.         System.out.println(mhQuery);
    6.     }
    7. }
     

     

     

    五、MyBatis之resultType
     

    5.1resultType概述：
             resultType：表示Mapper接口里面方法的返回类型，包括基本数据类型和复杂数据类型。里面的值是数据类型的完全限定名或者别名。
             给类取别名；
             注，当方法返回的是 List集合，resultType属性里面的值不是 java.util.List，是List集合里面存储数据的类型，如：com.zking.model.Book。
         
    5.2resultType返回复杂类型之Map类型(单条数据). 返回类型：java.util.Map
             resultType返回类型也可以是一个Map集合，就是把查询出来的数据以键值对的形式存放到一个Map集合里面，数据表的字段是Map里面的键，值是Map里面的值，并进行返回。
             当 resultType的返回类型是 Map类型的时候，不需要创建对应的Java实体类，因为数据是保存在一个 Map集合里面，一般用来进行联表查询;
             注:
                 当resultType返回类型时Map集合的时候，sql语句返回的结果最多只能有一条数据（可以有很多个字段，甚至来自不同的表）。
                 Map集合里面键是数据表里面的字段名，和java实体类的属性名没有任何关系。
     

        5.3resultType返回复杂类型之Map(多条数据). 返回类型：java.util.Map
             当返回类型的是map集合的时候最多只能返回一条数据，为了解决这个问题，我们可以把Mapper接口的方法的返回类型改成 List类型，List集合里面存储的是一个 Map集合。
             
     


    六、MyBatis之resultMap
     


         作用：是引用外部自定义的 resultMap ，通过自定义的 resultMap的 id 进行引用，表示将返回结果映射到自定义的 resultMap 上，它可以将查询到的复杂数据（比如查询到几个表中数据）映射到一个结果集当中。
         resultMap 应用场景：一般是当表的字段名与Java对象属性名不一致或者需要做复杂的联合查询以便自由控制映射结果的情况。而在实际开发中数据库的字段名和Java对象的属性名是不一致的(因为数据库和Java的命名规范不一样)，所以 resultMap 在实际开发中应用非常广泛。当然，如果表的字段名和Java对象的属性名一致，那么 resultMap 也可以实现自动映射。
     


        如：
         
             
             
             
         
         
     


    七、MyBatis之分页插件PageHelper
     


    7.1PageHelper插件介绍
     

            为什么要使用分页插件？MyBats自带的分页功能很弱，是基于内存的分页，在大数据量的情况下基本上是没有用的；
             不同的数据库实现分页的方式是不一样的，比如：mysql是limit、sqlserver是top、oracle是rownum。PageHelper是国人开发的一个实现分页的插件，它可以实现对任何数据库的分页功能。
             PageHelper插件实现分页的原理是：根据使用不同的数据库，它会自动在执行的sql语句后面加所使用数据库对应的分页代码，比如：mysql是limit、sqlserver是top、oracle是rownum。
         
     

    7.2使用步骤
     

    7.2.1添加PageHelper依赖. 5.2.1；
     

    1. <dependency>
    2.   <groupId>com.github.pagehelpergroupId>
    3.   <artifactId>pagehelperartifactId>
    4.   <version>5.2.1version>
    5. dependency>
     

     

    7.2.2在mybatis核心配置文件里添加分页插件拦截器插件（注意添加的位置）；
     

    1.   <plugins>
    2.       <plugin interceptor="com.github.pagehelper.PageInterceptor">plugin>
    3.   plugins>
     

     

    注意：放在environments标签的上面
     

    


    
    
    
    
        
        
    
    
    



    
    
    
    
    
    
    
        
    
    
        
        
            
            
            
            
                
                
                
                
                
                
                
                
            
        
    
    
    
        



        


    
 
     

     

    7.2.3添加PageBean工具类；
     

    1. package com.zking.util;
    2.  
    3. import java.io.Serializable;
    4. import java.util.Map;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7.  
    8.  
    9. public class PageBean implements Serializable {
    10.  
    11.    //页码
    12.    private int page=1;
    13.    //每页显示条数
    14.    private int rows=10;
    15.    //总记录数
    16.    private int total=0;
    17.    //是否分页标记
    18.    private boolean pagination=true;
    19.    //上一次请求的路径
    20.    private String url;
    21.    //请求参数Map集合
    22.    private Map<String,String[]> map;
    23.    
    24.    public String getUrl() {
    25.       return url;
    26.    }
    27.    public void setUrl(String url) {
    28.       this.url = url;
    29.    }
    30.    public Map<String, String[]> getMap() {
    31.       return map;
    32.    }
    33.    public void setMap(Map<String, String[]> map) {
    34.       this.map = map;
    35.    }
    36.    public int getPage() {
    37.       return page;
    38.    }
    39.    public void setPage(int page) {
    40.       this.page = page;
    41.    }
    42.    public int getRows() {
    43.       return rows;
    44.    }
    45.    public void setRows(int rows) {
    46.       this.rows = rows;
    47.    }
    48.    public int getTotal() {
    49.       return total;
    50.    }
    51.    public void setTotal(int total) {
    52.       this.total = total;
    53.    }
    54.    public boolean isPagination() {
    55.       return pagination;
    56.    }
    57.    public void setPagination(boolean pagination) {
    58.       this.pagination = pagination;
    59.    }
    60.    
    61.    //重载setPage/setRows/setPagination方法
    62.    public void setPage(String page) {
    63.       if(null!=page&&!"".equals(page))
    64.          this.page=Integer.parseInt(page);
    65.    }
    66.    public void setRows(String rows) {
    67.       if(null!=rows&&!"".equals(rows))
    68.          this.rows=Integer.parseInt(rows);
    69.    }
    70.    public void setPagination(String pagination) {
    71.       if(null!=pagination&&!"".equals(pagination))
    72.          this.pagination=Boolean.parseBoolean(pagination);
    73.    }
    74.    
    75.    public void setRequest(HttpServletRequest req) {
    76.       //获取前端提交的page/rows/pagination参数
    77.       String page=req.getParameter("page");
    78.       String rows=req.getParameter("rows");
    79.       String pagination=req.getParameter("pagination");
    80.       
    81.       //设置属性
    82.       this.setPage(page);
    83.       this.setPagination(pagination);
    84.       this.setRows(rows);
    85.       
    86.       //设置上一次请求的路径
    87.       //第一次请求：
    88.       //http://localhost:8080/项目名/请求路径.action?page=1
    89.       //第二次请求：下一页  page=2
    90.       //项目名+请求路径.action
    91.       //req.getContextPath()+req.getServletPath()==req.getRequestURI()
    92.       this.url=req.getRequestURI();
    93.       
    94.       //获取请求参数集合
    95.       // checkbox name='hobby'
    96.       // Map hobby==key  value==new String[]{"篮球","足球",..}
    97.       this.map=req.getParameterMap();
    98.    }
    99.    
    100.    /**
    101.     * 获取分页的起始位置
    102.     * @return
    103.     */
    104.    public int getStartIndex() {
    105.       //第1页：(1-1)*10  ==0    limit 0,10
    106.       //第2页：(2-1)*10  ==10   limit 10,10
    107.       //..
    108.       return (this.page-1)*this.rows;
    109.    }
    110.    
    111.    //获取末页、上一页、下一页
    112.    /**
    113.     * 获取末页
    114.     * @return
    115.     */
    116.    public int getMaxPager() {
    117.       int maxPager=this.total/this.rows;
    118.       if(this.total%this.rows!=0)
    119.          maxPager++;
    120.       return maxPager;
    121.    }
    122.    
    123.    /**
    124.     * 获取上一页
    125.     * @return
    126.     */
    127.    public int getPreviousPager() {
    128.       int previousPager=this.page-1;
    129.       if(previousPager<=1)
    130.          previousPager=1;
    131.       return previousPager;
    132.    }
    133.    
    134.    /**
    135.     * 获取下一页
    136.     * @return
    137.     */
    138.    public int getNextPager() {
    139.       int nextPager=this.page+1;
    140.       if(nextPager>getMaxPager())
    141.          nextPager=getMaxPager();
    142.       return nextPager;
    143.    }
    144.    @Override
    145.    public String toString() {
    146.       return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pagination=" + pagination
    147.             + ", url=" + url + ", map=" + map + "]";
    148.    }
    149.    
    150. }
     

    然后添加依赖servlet-api 2.5
     

    1. <dependency>
    2.   <groupId>javax.servletgroupId>
    3.   <artifactId>servlet-apiartifactId>
    4.   <version>2.5version>
    5. dependency>
     

     

    7.2.4定义分页方法；
     

    1.在BookMapper里面定义带模糊查询的分页，不带PageBean（分页）参数；
     

    List<Book> queryPageBean(Book book);
     

    2.BookMapper.xml编写sql（sql语句会被分页拦截器插件自动拦截，自动添加分页代码）；
     

    1. <select id="queryPageBean" resultType="com.zking.model.Book">
    2.     select
    3.     "Base_Column_List"/>
    4.     from t_book where true
    5.     <if test="null != booName and '' != bookNamw">
    6.         and book_name like concat('%',#{bookName},'%')
    7.     if>
    8. select>
     

     

    3.service包
     

    接口，带PageBean（分页）参数
     

    List<Book> queryPageBean(Book book, PageBean pageBean);
     

     

    实现类，返回的参数不需要带PageBean（分页）参数，会报错
     

    1. @Override
    2. public List<Book> queryPageBean(Book book, PageBean pageBean) {
    3.     return bookMapper.queryPageBean(book);
    4. }
     

     

    4.测试
     

    1. @Test
    2. public void queryPageBean(){
    3.     PageBean pageBean = new PageBean();
    4.  
    5.     // 设置当前页码（当前展示的页数）
    6.     pageBean.setPage(2);
    7.     // 设置页大小（每页展示多少条数）
    8.     pageBean.setRows(5);
    9.  
    10.     // 判断是否要分页
    11.     if(null != pageBean && pageBean.isPagination()){
    12.         // 调用PageHelper插件的startPage()方法：开始分页（传入当前页码（当前展示第几页）和页大小（每页展示的条数））
    13.         PageHelper.startPage(pageBean.getPage(),pageBean.getRows());
    14.     }
    15.  
    16.     List<Book> books = bookServiceImpl.queryPageBean(null, pageBean);
    17.     books.forEach(System.out::println);
    18. }
     

    获取分页信息
     

    1. // 获取分页信息（不包含总条数）
    2. PageInfo pageInfo = new PageInfo();
    3. // 把查询出来的分页集合数据赋给PageInfo集合（全部）
    4. pageInfo.setList(listBook);
    5.  
    6. System.out.println("pageInfo = " + pageInfo);
     

     

    完。
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
npm包停止了对 require 导入方式的支持，只允许使用import 导入方式，怎么解决                            
    
Java学习-详述main方法、可变参数、数组的工具类、二维数组                            
    
电脑文件夹加密怎么做？6步教你设置文件夹密码                            
    
Optional静态类简介以及用法                            
    
强大的pdf编辑软件：Acrobat Pro DC 2023中文                            
    
【Python】《Python编程：从入门到实践 (第2版) 》笔记-汇总                            
    
关于指数加权平均（一阶低通滤波）                            
    
为什么要使用elasticsearch                            
    
prompt learning 术语中文翻译                            
    
鸿蒙开发之ArkTS 基础九 枚举类型                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/weixin_62332711/article/details/125963805
                
    •