OK，在上一篇中，我们从对象的角度将数据从传统的SQL数据库筛选模式转换了出来，这样做的好处在于如果数据量不是特别大的情况下，一次性的提取出数据缓存到缓存中，将数据的操作从数据库中脱离出来，利用对象在缓存的基础上操作，从而更高效率的处理数据。 

上一节中，主要对数据的筛选做了分析与运用，当然，在大多数情况下，排序也是一个常用且重要的数据操作。 

在对业务对象进行排序时，不能使用ObjectDataSource作为数据源，因为它只支持DataView、DataTable、DataSet的自动排序。当然，仍然可以对GridView进行Sorting处理，直接拼装SQL语句，利用“Order By”子句即可完成排序。 

基本的数据库操作这里就不再举例，和进行数据筛选思路一样，我们同样可以将数据一次性抽到缓存中，后继的请求只针对缓存了的业务对象进行。本节将在上篇的基础上讨论如何对业务对象进行排序，包括简单排序和高级排序。 

同样，我们这里先建立一个显示交互页面（由于ObjectDataSource的原因无法用之前的列子）。创建一个AgriDataSort.aspx文件，拖放一个Repeater控件，编写前端代码：



<asp:Repeater ID="rpAgriDataList" runat="server">
            <HeaderTemplate>
                <table>
                    <tr>
                        <th>                     
                            <asp:LinkButton runat="server" ID="lbtDataID">AgriDataID</asp:LinkButton>                                                        
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataTem">AgriDataTem</asp:LinkButton>                               
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataSun">AgriDataSun</asp:LinkButton>                                      
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataEle">AgriDataEle</asp:LinkButton>
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataWater">AgriDataWater</asp:LinkButton>
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataBelong">AgriDataBelong</asp:LinkButton>
                        </th>
                        <th>
                            <asp:LinkButton runat="server" ID="lbtAgriDataTime">AgriDataTime</asp:LinkButton>                                
                        </th>
                    </tr>
                </HeaderTemplate>
            <ItemTemplate>
                <tr>
                    <td><%#Eval("ID") %></td>
                    <td><%#Eval("Tem") %></td>
                    <td><%#Eval("Sun") %></td>
                    <td><%#Eval("Ele") %></td>
                    <td><%#Eval("Water") %></td>
                    <td><%#Eval("Belong") %></td>
                    <td><%#Eval("Date") %></td>
                </tr>
            </ItemTemplate>
            <FooterTemplate>
                </table>
            </FooterTemplate>        
        </asp:Repeater>   

显示效果如图： 


接下来用相同的方法将要处理的数据放入到缓存中，我们在ObjAgriManager类下创建该方法（方便显示就提取前十五条数据）：



public static List<AgriData> GetSortList()
        {
            List<AgriData> list = HttpContext.Current.Cache["SortList"] as List<AgriData>;

            if (list == null)
            {
                //获取前15条记录
                list = SqlAgriDataManager.GetList("select Top (15) * from AgriData");
                HttpContext.Current.Cache.Insert("SortList", list);
            }

            return list;
        }

基本的数据源得到之后，将它与页面链接起来，在AgriDataSort.aspx.cs的Page_Load事件下，将数据源绑定：



protected void Page_Load(object sender, EventArgs e)
{
    List<AgriData> list = ObjAgriDataManager.GetSortList();

    rpAgriDataList.DataSource = list;
    rpAgriDataList.DataBind();
}

运行效果如下： 


简单排序——IComarable接口的实现

接下来便进行简单的排序操作，利用集合自带的Sort方法即可，通常代码会这样编写：



List<AgriData> list = ObjAgriDataManager.GetSortList();
            list.Sort();
            rpAgriDataList.DataSource = list;
            rpAgriDataList.DataBind();

实际上这段代码是会报错的，原因很简单，没有实现IComparable< T>接口，从本质上讲，List< T>.Sort()的实现基础就是实现了IComparable< T>接口，而诸如int、char、string一类基础类型都是实现了该接口才能进行排序操作的。 

IComparable< T>的定义很简单:



    public interface IComparable<in T>
    {
        // 摘要: 
        //     比较当前对象和同一类型的另一对象。
        //
        // 参数: 
        //   other:
        //     与此对象进行比较的对象。
        //
        // 返回结果: 
        //     一个值，指示要比较的对象的相对顺序。 返回值的含义如下： 值 含义 小于零 此对象小于 other 参数。 零 此对象等于 other。 大于零
        //     此对象大于 other。
        int CompareTo(T other);
    }

详细的注释源码上已经很清楚了，根据返回额int型数值，来判断数据的先后位置。我们这里默认根据Tem的大小进行比较，因为在业务对象AgriData中Tem的类型为int,所以比较操作可以直接调用其CompareTo方法：



 public class AgriData:IData,IComparable<AgriData>
    {
        //...略

       int IComparable<AgriData>.CompareTo(AgriData other)
        {
            return this.Tem.CompareTo(other.Tem);
        }
    }

运行程序，效果如预期所致： 




高级排序——IComparer接口的实现

很显然，在实际运用中，我们经常需要对多个列进行排序，同时还要考虑升序和降序，比如我们先对ID进行升序排列，再对Sun值进行降序排列，这种情况下CompareTo虽然也可以实现但需要对AgriData添加额外的属性。这些.Net Framework已经考虑到了，并提供IComparer< T>接口进行了排序规则。



    public interface IComparer<in T>
    {
        // 摘要: 
        //     比较两个对象并返回一个值，指示一个对象是小于、等于还是大于另一个对象。
        //
        // 参数: 
        //   x:
        //     要比较的第一个对象。
        //
        //   y:
        //     要比较的第二个对象。
        //
        // 返回结果: 
        //     一个有符号整数，指示 x 与 y 的相对值，如下表所示。 值 含义 小于零 x 小于 y。 零 x 等于 y。 大于零 x 大于 y。
        int Compare(T x, T y);
    }

IComparer< T>同样需要实现一个方法，Compare（），计算机制和CompareTo基本相同，不过需要注意的是，这个接口不是要求AgriData对象实现的，而是要求另一个对象实现它，比如AgriDataComparer，而在调用Sort方法时，再将它作为参数传递过去，由于这个AgriDataComparer只针对AgriData进行，所以将它作为嵌套类更为合适。 

首先考虑到排序的规则（升降？对那一列进行升降？），这里同样可以定义2个内部枚举：



 public enum SortDir { Ascending = 0, Descending }
        public enum SortField { ID, Tem, Ele, Sun, Water, Belong, Date }

为了方便将这两个规则做参数处理，我们将它设计为一个结构体：



 //内部排序属性结构体
        public struct Sorter 
        {
            public SortDir dir;
            public SortField field;

            public Sorter(SortField field,SortDir dir)
            {
                this.dir = dir;
                this.field = field;
            }
        }

这个排序规则结构体就作为AgriDataComparer的内部的字段存储，当然，实际中一组排序规则不一定足够，所以最好封装成List< Sorter>存储给为合适：



  public class AgriDataComparer : IComparer<AgriData>
        {
            //一组排序规则集合
            private List<Sorter> list;
        }

 public AgriDataComparer(List<Sorter> list)
            {
                this.list = list;
            }

我们先从简单的单个属性的某种升降序入手，不考虑多个属性，我们来便写一个Compare方法体：



 public int Compare(AgriData x, AgriData y, SortDir dir, SortField field)
            {
                int result = 0;

                switch (field)
                {
                    case SortField.ID:
                        if (dir == SortDir.Ascending) result = x.ID.CompareTo(y.ID);
                        else result = y.ID.CompareTo(x.ID);
                        break;
                    case SortField.Tem:
                        if (dir == SortDir.Ascending) result = x.Tem.CompareTo(y.Tem);
                        else result = y.Tem.CompareTo(y.Tem);
                        break;
                    case SortField.Sun:
                        if (dir == SortDir.Ascending) result = x.Sun.CompareTo(y.Sun);
                        else result = y.Sun.CompareTo(x.Sun);
                        break;
                    case SortField.Ele:
                        if (dir == SortDir.Ascending) result = x.Ele.CompareTo(y.Ele);
                        else result = y.ID.CompareTo(x.Ele);
                        break;
                    case SortField.Water:
                        if (dir == SortDir.Ascending) result = x.Water.CompareTo(y.Water);
                        else result = y.ID.CompareTo(x.Water);
                        break;
                    case SortField.Belong:
                        if (dir == SortDir.Ascending) result = x.Belong.CompareTo(y.Belong);
                        else result = y.ID.CompareTo(x.Belong);
                        break;
                    case SortField.Date:
                        if (dir == SortDir.Ascending) result = x.Date.CompareTo(y.Date);
                        else result = y.ID.CompareTo(x.Date);
                        break;
                }

通过传递的2个AgriData对象，和属性、升降序规则，对对象进行排序操作，不过，这个方法不能作为IComparer< T>的实现方法，因为IComparer< T>.Compare只接受两个参数传递，那么排序规则怎么去处理呢？多个排序规则又怎么处理呢？这个时候之前定义的List< Sorter>集合和之前的Compare就派上用场了，我们只要遍历List< Sorter>这个集合，每轮遍历对其中的排序规则调用之前定义的Compare方法处理即可，当两个值的某个属性相等时，触发下一组排序属性直到两个值不同为止：



 //实现ICompare接口
            int IComparer<AgriData>.Compare(AgriData x, AgriData y)
            {
                int result = 0;

                foreach (Sorter n in list)
                {
                    result = Compare(x, y, n.dir, n.field);
                    if (result != 0) break;
                }

                return result;
            }

哈哈，代码就是这么简单，这样就很好的解决了多组排序规则的处理。 

为了方便Sort方法参数的传递，我们继续编写一组GetCompare方法做相关处理，首先我们看下按排序要求进行的Sort重载方法：



public void Sort(IComparer<T> comparer);

很显然，我们只要传递一个IComparer< T>类型的参数即可，为了方便调用，我们将GetCompare作为静态方法，并且返回类型为IComparer< T>，所以这组重载方法可以这样定义：



 //单个指定排序
            public static AgriDataComparer GetComparer(SortField field,SortDir dir)
            {
                Sorter sorter = new Sorter(field, dir);
                List<Sorter> list = new List<Sorter>();
                list.Add(sorter);
                return new AgriDataComparer(list);
            }

            //单个默认排序——ID、升序
            public static AgriDataComparer GetComparer()
            {
                List<Sorter> list = new List<Sorter>()
                {
                    new Sorter(SortField.ID,SortDir.Ascending),
                };
                return new AgriDataComparer(list);
            }

            //多个指定排序
            public static AgriDataComparer GetComparer(List<Sorter> list)
            {
                return new AgriDataComparer(list);
            }

好的，我们在页面的后台进行测试：



 protected void Page_Load(object sender, EventArgs e)
        {
            List<AgriData.Sorter> sorter = new List<AgriData.Sorter>()
            {
                //1级条件——光照度降序
                new AgriData.Sorter(AgriData.SortField.Sun,AgriData.SortDir.Descending),
                //2级条件——湿度升序
                new AgriData.Sorter(AgriData.SortField.Water,AgriData.SortDir.Ascending),
            };

            List<AgriData> list = ObjAgriDataManager.GetSortList();
            list.Sort(AgriData.AgriDataComparer.GetComparer(sorter));
            rpAgriDataList.DataSource = list;
            rpAgriDataList.DataBind();
        }

运行如图： 


确实完成了我们的要求。

查询：

 

如果一个界面中有联合查询的话，再写SQL语句进行查询就比较麻烦了，那么这个时候，就可以用到DataSet了。

首先在有联合查询的界面的load事件里面 实例化一个DataSet，然后将后台查询出来的DataSet赋值给这个DataSet，然后在给这个datagridview赋值的时候，赋值的数据源是这个DataSet，然后在用户查询的时候，判断根据用户输入的条件对这个DataSet进行行过滤就可以了。

详细的行过滤代码：

this.ds.Tables[0].DefaultView.RowFilter = 需要过滤的条件

在上面中，

ds：就是自己实例化的DataSet

RowFilter 后面就是根据需求自己来写过滤条件就可以了。

sort：

对datagridview中的数据进行sort 也用到了DataTable。

首先将DataSet中的数据表赋值给一个DataTable，

然后直接用DataTable.Sort就可以。后面给上条件就行了。

案例：

this.dt.DefaultView.Sort = string.Format("{0} desc ",this.comboBox1.Text.Trim());

 

运算符总结
 
逻辑运算举例
 
表格可以通过右边属性的单元格下面的图标进行删除增加等操作 表格的每个格子有各自的名称 整个表格也有整个的名称


然后创建中继器 数据填入进去 同时上面的矩形也要命名
将excel的数据直接复制过来
一定要记得设置中继器的动作 每项加载时 item.xuhao就是数据里的xuhao 让中继器框更新数据库里的数据的动作 不然不会显示出来
 
对身高进行排序 添加排序 取名字 注意属性要设置好对应的框 然后降序 降序就是从高到矮
 
对生日进行排序 注意排序类型不是数字而是日期（日期有两种格式 选择合适的 不然没反应） 同时顺序应用了切换 默认是升序
然后我们给排序设置一个移除所有排序的动作 意思就是点排序就恢复到原始数据状态
 注意对性别筛选的操作 首先选择选项改变时 然后添加筛选
 
对性别筛选的公式操作 首先用局部变量获取用户选取的性别 然后通过公式找到性别等于选中的数据 注意被选项与下拉列表框
 进行身高筛选 对查看进行动作鼠标单击时 添加筛选
 
身高筛选公式操作 注意两公式中间是并且的逻辑关系
 
但是以上有个问题 就是性别筛选跟身高筛选是同时存在的 不能只用一个筛选 怎么做？
 
  类似与标记 先移除所有再添加 性别跟查看都要设置先移除再添加
 
转载于:https://www.cnblogs.com/newt/p/9207834.html

前言
在项目开发过程中遇到这样的业务需求，在网上也找了许多资料，但是都比较复杂，需要花点时间去理解，用了各种方法踩坑之后，也请教了一下大佬ES方面的相关知识，最主要还是因为刚用ES不久，所以对ES的用法，数据结构什么的，都不是很熟悉，导致花了比较长的时间去实现这个业务需求，现在就对这个聚合搜索的具体实现代码列出来，供大家参考。
正文
ES索引的Mapping
{
  "mappings": {
    "properties": {
      "aid": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "content": {
        "type": "keyword",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "tagCode": {
        "type": "keyword",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "tagValue": {
        "type": "keyword",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "createDateTime": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "fromModule": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "fromWeb": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "html": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "publisher": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "releaseDateTime": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "title": {
        "type": "keyword",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "updateDateTime": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "url": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "webCla": {
        "type": "keyword",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      }
    }
  }
}

在一开始使用ES的时候，并不知道说ES对精准查询的要求是对应字段的数据类型需要是Keyword才可以，一开始创建的时候都用的Text类型，所以导致进行模糊查询匹配的时候，一直出现不符合的数据。
在需要做时间范围筛选或者排序的字段上，记得用上date类型，并且加上format，可以保证多种格式都能自动转义。
JAVA代码
pom依赖
<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

Entity 类
package com.crawler.service.docment;

import com.baomidou.mybatisplus.annotation.TableField;
import com.crawler.common.base.IdEntity;
import com.crawler.common.constant.GlobalConstant;
import lombok.Data;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.util.List;

@Data
@Document(indexName = "idx_article", type = GlobalConstant.TYPE_OR_FAMILY)
public class Article extends IdEntity {

    @Field(type = FieldType.Keyword)
    private String aid;//ID
    @Field(type = FieldType.Keyword)
    private String title;//标题
    @Field(type = FieldType.Keyword, analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")
    private String content;//内容
    @Field(type = FieldType.Text)
    private String publisher;//发布者、出版商
    @Field(type = FieldType.Date, fielddata=true)
    private String releaseDateTime;//发布日期
    @Field(type = FieldType.Text)
    private String url;
    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")
    private String html;//HTML
    @Field(type = FieldType.Keyword)
    private String fromWebId;//来源网站ID
    @Field(type = FieldType.Text)
    private String fromWeb;//来源网站
    @Field(type = FieldType.Keyword)
    private String fromModuleId;//来源网站模块ID
    @Field(type = FieldType.Text)
    private String fromModule;//来源网站模块
    @Field(type = FieldType.Date)
    private String createDateTime;
    @Field(type = FieldType.Date)
    private String updateDateTime;
    @Field(type = FieldType.Keyword)
    private String webCla;//引擎类型，1、2、3、4、5
    @Field(type = FieldType.Keyword)
    private String tagCode;//code1,code2
    @Field(type = FieldType.Keyword)
    private String tagValue;//{code1:"",code2:""}
    @TableField(exist = false)
    private List<String> webClasses;
}

Repository类
就简单的继承了ElasticsearchRepository父类
package com.crawler.service.repository;

import com.crawler.service.docment.Article;
import com.crawler.service.entity.Company;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article, String> {
}

Controller
@ApiOperation(value = "获取舆情新闻列表", notes = "获取公司基本信息列表")
@RequestMapping(value = "/listByKeyword", method = RequestMethod.POST)
@ResponseBody
public CommonResult listByKeyword(@RequestBody Article article) {
    Page<Article> articles = iArticleService.listByKeyword(article);
    return CommonResult.success(articles);
}

Impl实现类
主要的逻辑都在这里实现，我写的比较简单，坑都是在这边踩完了，具体的说明都写在了注释里面。
package com.crawler.service.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.crawler.service.docment.Article;
import com.crawler.service.mapper.ArticleMapper;
import com.crawler.service.repository.ArticleRepository;
import com.crawler.service.service.IArticleService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * @author LinZS
 * @description
 * @date 2020/12/9 15:02
 */
@Service
@Slf4j
public class IArticleServiceImpl extends ServiceImpl<ArticleMapper, Article> implements IArticleService {

    @Autowired
    private ArticleRepository articleRepository;

    @Override
    public Page<Article> listByKeyword(Article article) {
        //查询对象
        BoolQueryBuilder queryBuilder = new BoolQueryBuilder();
        //模糊搜索对象
        BoolQueryBuilder keyBuilder = new BoolQueryBuilder();
        //分类查询对象
        BoolQueryBuilder orBuilder = new BoolQueryBuilder();
        //拼接模糊搜索条件
        if (StringUtils.isNotBlank(article.getKeyword())){
            //这边主要用的是should，也就是相当于mysql的or   title like concat('%keyword%') or content like concat('%keyword%') 
            //wildcardQuery可以用于带分词的模糊搜索，如果要分词的话，那么字段的type应该是text，假如在用wildcardQuery而不想分词的话，可以查.keyword
            //例如title.keyword，不过我这边title的type已经定了是keyword类型，所以我就直接做不分词的模糊查询，精确查询的话就用matchQuery
            keyBuilder.should(QueryBuilders.wildcardQuery("title", "*"+article.getKeyword()+"*"));
            keyBuilder.should(QueryBuilders.wildcardQuery("content", "*"+article.getKeyword()+"*"));
            queryBuilder.must(keyBuilder);
        }
        //拼接分类筛选条件
        if (article.getWebClasses() != null && article.getWebClasses().size() > 0){
            //这里主要是实现了多条件筛选的需求，前端有复选框的条件筛选，后端以集合方式接收，然后做or的条件拼接 webCla = '1' or webCla = '2'...
            article.getWebClasses().forEach(s ->
                    orBuilder.should(QueryBuilders.matchQuery("webCla",s)));
            queryBuilder.must(orBuilder);
        }
        //时间范围筛选
        if (article.getTimeLimit() > 0){
            //这边是获取了距离今天多少天以前的日期
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - article.getTimeLimit());
            //范围筛选就用rangeQuery 相当于 >= 'xx' and <= 'xx'   还有gt方法和lt方法就是不带 '='
            QueryBuilder queryRange = QueryBuilders.rangeQuery("releaseDateTime")
                    .gte(new SimpleDateFormat("yyyy-MM-dd")
                            .format(calendar.getTime()))
                    .lte(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                            .format(new Date()));
            queryBuilder.filter(queryRange);
        }
        //分页查询并按发布时间排序
        //这边的分页只能算是form-size的浅层分页，如果数据量大的话，建议改造成scroll深度分页
        Pageable pageable = PageRequest.of(article.getStart(), article.getLimit(), Sort.Direction.DESC,"releaseDateTime");
        Page<Article> search = articleRepository.search(queryBuilder,pageable);
        return search;
    }
}

整个嵌套下来，相当于SQL   select * from table where （title like concat(’%keyword%’) or content like concat(’%keyword%’) ）and ( webCla = ‘1’ or webCla = ‘2’…) and (releaseDateTime >= ‘xx’ and releaseDateTime <= ‘xx’   (或者between and 一个意思)) order by releaseDateTime desc;
聚合查询结果

这个是分页的数据，总共hits是44条，我limit了1，所以展示1条

希望这篇文章能帮助到有这方面业务需求的coder~