精华内容
下载资源
问答
  • OK,在上一篇中,我们从对象的角度将数据从传统的SQL数据库...上一节中,主要数据的筛选做了分析与运用,当然,在大多数情况下,排序也是一个常用且重要的数据操作。 在业务对象进行排序时,不能使用ObjectDataS

    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();
            }

    运行如图:
    这里写图片描述
    确实完成了我们的要求。

    展开全文
  • 实例化一个DataSet,然后将后台查询出来的DataSet赋值给这个DataSet,然后在给这个datagridview赋值的时候,赋值的数据源是这个DataSet,然后在用户查询的时候,判断根据用户输入的条件这个DataSe...

    查询:

     

    如果一个界面中有联合查询的话,再写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());

     

    展开全文
  • 运算符总结 逻辑运算举例 表格可以通过右边属性的单元格下面的...一定要记得设置中继器的动作 每项加载时 item.xuhao就是数据里的xuhao 让中继器框更新数据库里的数据的动作 不然不会显示出来 身高进行...

    运算符总结

     

    逻辑运算举例

     

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

    然后创建中继器 数据填入进去 同时上面的矩形也要命名

    将excel的数据直接复制过来

    一定要记得设置中继器的动作 每项加载时 item.xuhao就是数据里的xuhao 让中继器框更新数据库里的数据的动作 不然不会显示出来

     

    对身高进行排序 添加排序 取名字 注意属性要设置好对应的框 然后降序 降序就是从高到矮

     

    对生日进行排序 注意排序类型不是数字而是日期(日期有两种格式 选择合适的 不然没反应) 同时顺序应用了切换 默认是升序

    然后我们给排序设置一个移除所有排序的动作 意思就是点排序就恢复到原始数据状态

     注意对性别筛选的操作 首先选择选项改变时 然后添加筛选

     

    对性别筛选的公式操作 首先用局部变量获取用户选取的性别 然后通过公式找到性别等于选中的数据 注意被选项与下拉列表框

     进行身高筛选 对查看进行动作鼠标单击时 添加筛选

     

    身高筛选公式操作 注意两公式中间是并且的逻辑关系

     

    但是以上有个问题 就是性别筛选跟身高筛选是同时存在的 不能只用一个筛选 怎么做?

     

      类似与标记 先移除所有再添加 性别跟查看都要设置先移除再添加

     

    转载于:https://www.cnblogs.com/newt/p/9207834.html

    展开全文
  • 在项目开发过程中遇到这样业务需求,在网上也找了许多资料,但是都比较复杂,需要花点时间去理解,用了各种方法踩坑之后,也请教了一下大佬ES方面相关知识,最主要还是因为刚用ES不久,所以ES用法,数据结构...

    前言

    在项目开发过程中遇到这样的业务需求,在网上也找了许多资料,但是都比较复杂,需要花点时间去理解,用了各种方法踩坑之后,也请教了一下大佬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;

    聚合查询结果

    image-20201216173950699

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

    image-20201216174219960

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

    展开全文
  • 1、如何汉字数字混搭的数据列进行排序?如下图所示,如何将班级从小到大进行排序?想实现排序,这里可以借用Ctrl+E来实现。先将班级数字提取出来,之后选中单元格区域按Ctrl+E进行快速填充,然后再点击数据——...
  • //以1为步长,双向式,对数据排序 function zpx(fz,zf){ //zf排序开始位置,fz排序结束位置 for(fz;fz;zf){ var mi=fz; //记录最小值 var ma=zf-1; //记录最大值 if(arr[fz]>arr...
  • 阿金:如果自动筛选是文本数据,那么在筛选下拉列表中有一个搜索框,可以直接打入关键字,那么,包含有关键字记录就会筛选出来。 秀秀:啊!那是在高版本下才有呀! 阿金:,但是这个功能很有用, 秀秀...
  • 数据的图表展示

    2019-11-03 23:53:32
    数据的预处理是在对数据分类或者分组前所作必要处理,包括数据的审核、筛选排序等。 数据审核;就是检查数据中是否又错误。对于通过调查取得原始数据,主要从完整性和准确性两个方面审核。对于通过其他渠道...
  • 当第一次循环结束时,最大元素就被筛选出来,然后进入第二次循环,以此类推,直到没有任何一对数据进行比较。下面看一个案例:假设有5个数字,依次为:5,4,6,3,1用冒泡排序的思想来实现话,过程是这样:外层第...
  • 归并与基数排序

    2020-12-07 21:47:55
    选择题 1.输入10​​^5个只有一位数字的整数,可以用O(N)复杂度将其排序的...如果是堆排序,末尾因该是筛选出来的两个数。 3.10TB的数据文件进行排序,应使用的方法是:归并排序 4.下列排序方法中,若将顺序存储
  • 相对有序排序算法

    2017-11-08 15:52:00
    当需要一批数据进行逐个筛选,并将筛选的数据存入一个容器中,当取出来进行第二次操作时,需要取出的数据是按一定的规则排序的时候。 drools加载并执行规则的时候,会去创建执行网络(Rete算法),用的排序方式...
  • 在sql语句将数据筛选出来后需要在程式在再数据进行操作比較频繁,以下为整理的部分常用处理方式。 1、DataTable.Select(); DataTable.Select()有4个方法的重载,可以进行简单的搜索和排序,以下为常用的数据处理...
  • ----------------------------范例一------------------------------------我们一般都需要从DataSet中提取出来的数据做一些简单的修饰,如隐藏特定列,按照某列排序。其实很简单,.net为我们...
  • 之前写一个需要用到排序的需求,对表排序筛选,选出来的数据立即处理。主要业务点:客户有1,2,3,4,5,6等级别,1-4级为一组,5,6级为一组,5-6级的优先处理,之后在处理1-4级。最早我写了一个子查询,将1-4归为...
  • 数据的排序 对数据排序的方法一种是以单一条件即只有一个关键字排序的简单排序法另一种是按照两个以上的关键字进行排序的方法也叫高级排序 数据的筛选 数据的筛选其实就是在数据表格中隐藏不需要的数据只显示满足...
  • Python数据操作步骤

    2018-09-12 07:09:46
    先对数据进行切割(split())--------再对需要数据进行筛选(判断条件)-------对筛选出来的数据进行二次操作(排序等等)
  • 数据统计是每个系统中必备功能,在给领导汇报统计数据,工作中需要进展数据时非常有用。 在我看来,一个统计模块应该实现以下... 对于保存后查询统计,下次调用时也可以按照灵活的筛选手段查询结果进行筛选
  • 如果满足,则生成新数组,这个新数组就是满足查询条件,条件:查询,并不是查询某一个值,还有查询某一个值满足某个条件,举个例子:查询数组中某个值大于5,全部筛选出来) 1、php中数组实质上是map结构,...
  • 最近重写的一个网站,需要对筛选的出来的id,查询详情时要保证筛选出来的顺序,MySQL自定义排序函数FIELD()可以满足需求,接下来吾爱编程就为大家介绍一下用法,有需要的小伙伴可以参考一下:1、语法格式:field...
  • 这里查找出来的记录进行简单的筛选. 筛选的关键词是where.和where搭配的子句操作符主要有:=,!=,&gt;,&lt;,BETWEEN,AND,OR,IN,NOT,NULL等等. Sample1:就是上面的这个表t1,我要检索出分数大于75的记录.只...
  • group by 分组,功能类似于EXCEL的数据透视,可以通过count(*)等分组结果进行运算,注意查询的元素都必须包含在分组group by后面 having 添加分组筛选条件 order by 可多重排序,根据会员数量降序:desc ,会员...
  • 学习sql小结之一

    2013-06-01 15:18:14
    首先总结一下sql 的编译顺序: ...group by :对筛选出来的数据进行分组; having:对分好的组进行筛选; select:对筛选好的数据进行调用; order by:对调用的数据排序输出。 1、基本select语句可实
  • 在把查询出来的数据进行筛选排序之后,需要获取的数据进行排序时,使用lambda中的groupingBy进行数据分组转成map,这个时候发觉map内的分组顺序并不是按照自己list的顺序来进行分组的,在经过排查后,最终发现在...
  • 我们从数据库里读取出来的数据一般都是DataTable数据类型,但是操作这样的数据类型没有“泛型集合模型”数据类型方便 更多的时候,我们要集合数据进行处理,从中筛选数据或者排序。 技能栈:泛型+反射 转换...
  • 运用mysql最多的便是查询,咱们火燎的期望mysql能查询的更快一些,咱们常常用到的查询有:依照id查询唯一一条记载依照某些个字段查询对应的记载查找某个规划的悉数记载(between and)查询出来的作用排序mysql的索引...
  • mongodb中的数据,做排序再做group还要做总数统计还要结果筛选,而且数据量又是百万级别的,看了整整一天的spring-data-mongo的源码、mongo-driver的源码、还逛了大半天国外论坛,总算是把功能搞出来了,在此...
  • 1 group by表示排序,后面查询出来的是每一组的第一条数据,where后面表示提出条件之类的,如果对排序需要有条件筛选,应该在属性名后接having +条件 。而不能使用where2 聚合函数sum() count() avg() max() min()...
  • 什么是todolist? 所谓的todolist就是把你所做...首先,所有的数据都是存储在localStorage中的;其次,文本框中输入内容后,回车即可添加任务主题;可以按内容和添加时间来排序任务;可以筛选任务,分为未完成和已完成;

空空如也

空空如也

1 2 3 4 5 6
收藏数 104
精华内容 41
关键字:

对筛选出来的数据排序