Elasticsearch From/Size、Scroll、Search After对比

From/Size

可以使用from和size参数对结果进行分页。from参数定义要获取的第一个结果的偏移量。 size 参数允许您配置要返回的最大匹配数。

简单来说，需要查询from + size 的条数时，coordinate node就向该index的其余的shards 发送同样的请求，等汇总到（shards * （from + size））条数时在coordinate node再做一次排序，最终抽取出真正的 from 后的 size 条结果。

注意from + size 不能超过 index.max_result_window 索引设置，默认为 10,000。 有关深入滚动的更有效方法，请参阅 Scroll 或 Search After API。

Search Type

在执行分布式搜索时可以执行不同的执行路径。分布式搜索操作需要分散到所有相关的shard，然后收集所有的结果。当使用分散/集中类型执行时，有几种方法可以做到这一点，特别是使用搜索引擎。

执行分布式搜索时的一个问题是从每个shard检索多少结果。例如，如果我们有 10 个shard，则第一个shard可能保存从 0 到 10 的最相关的结果，而其他shard的结果排在后面。因此，在执行请求时，我们需要从所有shard中获取从0到10的结果，对它们进行排序，然后返回结果(如果我们希望确保得到正确的结果)。

与搜索引擎相关的另一个问题是每个shard独立存在的事实。当在特定shard上执行查询时，它不会考虑来自其他shard上term频率及（其他shard上）搜索引擎的信息。如果我们想要支持准确的排名，我们需要首先收集所有shard中的term频率，以计算全局term频率，然后使用这些term频率对每个shard执行查询。

此外，由于需要对结果进行排序，在维护正确的排序行为的同时，获取大型文档集，甚至是滚动它，可能是一个非常昂贵的操作。对于大型结果集滚动，如果返回文档的顺序不重要，则最好按_doc排序。

Elasticsearch非常灵活，可以根据每个搜索请求控制执行的搜索类型。可以通过设置查询字符串中的search_type参数来配置类型。类型是:

Query Then Fetch

参数值： query_then_fetch。

请求分两个阶段处理。 在第一阶段，查询被转发到所有涉及的分片。 每个分片执行搜索并生成对该分片本地的结果的排序列表。 每个分片只向协调节点返回足够的信息，以允许其合并并将分片级结果重新排序为全局排序的最大长度大小的结果集。

在第二阶段期间，协调节点仅从相关分片请求文档内容（以及高亮显示的片段，如果有的话）。

如果您未在请求中指定 search_type，那么这是默认设置。

Dfs, Query Then Fetch

参数值：dfs_query_then_fetch

与 “Query Then Fetch” 相同，除了初始分散阶段，该阶段计算分布式term频率以获得更准确的评分。

Scroll与Search After 都依赖于Search Type

Search After

在日志服务架构设计中日志搜索后翻页、日志上下文的功能就是通过search_after实现的。

在官网文档中可以看出Search After有以下特点：

• 实时
• 可以深度分页（使用前一页的结果来帮助检索下一页）
• 不支持跳页

注意：每个文档具有一个唯一值的字段应用作排序规范的仲裁。 否则，具有相同排序值的文档的排序顺序将是未定义的。 建议的方法是使用字段 _uid（elasticsearch 6.x _uid 废弃 替换为_id），它确保每个文档包含一个唯一值。

Scroll

虽然搜索请求返回单个 “page” 的结果，但是滚动 API 可以用于从单个搜索请求中检索大量结果（甚至是所有结果），与在传统数据库上使用游标的方式大致相同。

滚动不是用于实时用户请求，而是用于处理大量数据，例如， 以便将一个索引的内容重新索引到具有不同配置的新索引中。

从滚动请求返回的结果反映了进行初始搜索请求时索引的状态，如时间快照。 对文档（索引，更新或删除）的后续更改只会影响以后的搜索请求。

可以把 scroll 分为初始化和遍历两步，初始化时将所有符合搜索条件的搜索结果缓存起来，可以想象成快照，在遍历时，从这个快照里取数据，也就是说，在初始化后对索引插入、删除、更新数据都不会影响遍历结果。

滚动请求具有优化，使排序顺序为_doc时更快。 如果你想迭代所有文档，无论顺序如何，这是最有效的选择：

GET /_search?scroll=1m
{
  "sort": [
    "_doc"
  ]
}

Keeping the search context alive

滚动参数（传递到搜索请求和每个滚动请求）告诉Elasticsearch应该保持搜索上下文活动的时间。其值（例如，1m，请参阅 “Time unit” 一节）不需要足够长以处理所有数据 - 它只需要足够长的时间来处理前一批结果。每个滚动请求（具有滚动参数）设置新的到期时间。

通常，后台合并过程通过将较小的段合并在一起以创建新的较大段来优化索引，此时较小的段被删除。此过程在滚动期间继续，但是打开的搜索上下文防止旧段在它们仍在使用时被删除。这就是Elasticsearch如何能够返回初始搜索请求的结果，而不考虑对文档的后续更改。

小结

如果要做非常多页的查询时，search after是一个常量查询延迟和开销，并无什么副作用，可是，就像要查询结果全量导出那样，要在短时间内不断重复同一查询成百甚至上千次，效率就显得非常低了。

本文内容来自官方文档，主要是做了翻译及汇总。

样例代码：
原始类：

@Repository
public class UserDaoImp implements UserDao {
    @Override
    public int addUser() {
        System.out.println("add user ......");
        return 6666;
    }

    @Override
    public void updateUser() {
        System.out.println("update user ......");
    }

    @Override
    public void deleteUser() {
        System.out.println("delete user ......");
    }

    @Override
    public void findUser() {
        System.out.println("find user ......");
    }
}

@Aspect
public class MyAspect {

    /**
     * 前置通知
     */
    @Before("execution(* com.zejian.spring.springAop.dao.UserDao.addUser(..))")
    public void before(){
        System.out.println("前置通知....");
    }

    /**
     * 后置通知
     * returnVal,切点方法执行后的返回值
     */
    @AfterReturning(value="execution(* com.zejian.spring.springAop.dao.UserDao.addUser(..))",returning = "returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知...."+returnVal);
    }


    /**
     * 环绕通知
     * @param joinPoint 可用于执行切点的类
     * @return
     * @throws Throwable
     */
    @Around("execution(* com.zejian.spring.springAop.dao.UserDao.addUser(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知前....");
        Object obj= (Object) joinPoint.proceed();
        System.out.println("环绕通知后....");
        return obj;
    }

    /**
     * 抛出通知
     * @param e
     */
    @AfterThrowing(value="execution(* com.zejian.spring.springAop.dao.UserDao.addUser(..))",throwing = "e")
    public void afterThrowable(Throwable e){
        System.out.println("出现异常:msg="+e.getMessage());
    }

    /**
     * 无论什么情况下都会执行的方法
     */
    @After(value="execution(* com.zejian.spring.springAop.dao.UserDao.addUser(..))")
    public void after(){
        System.out.println("最终通知....");
    }
}

编写配置文件交由Spring IOC容器管理

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 启动@aspectj的自动代理支持-->
    <aop:aspectj-autoproxy />

    <!-- 定义目标对象 -->
    <bean id="userDaos" class="com.zejian.spring.springAop.dao.daoimp.UserDaoImp" />
    <!-- 定义aspect类 -->
    <bean name="myAspectJ" class="com.zejian.spring.springAop.AspectJ.MyAspect"/>
</beans>

编写测试类：

/**
 * Created by zejian on 2017/2/19.
 * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= "classpath:spring/spring-aspectj.xml")
public class UserDaoAspectJ {
    @Autowired
    UserDao userDao;

    @Test
    public void aspectJTest(){
        userDao.addUser();
    }
}
————————————————
版权声明：本文为CSDN博主「zejian_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/javazejian/article/details/56267036

结果输出：

结论：

@After 被代理的方法执行完成之后，要执行的代码。

@AfterReturning 新生成的代理方法执行完成之后（return 之后），要执行的代码，是放在finally块中的。

备注：

很多人在评论区认为结论写反了， 可能是由于Spring官方文档也说After是最终（finally）通知，应该被最后执行。

Types of advice:

• Before advice: Advice that executes before a join point, but which does not have the ability to prevent execution flow proceeding to the join point (unless it throws an exception).

• After returning advice: Advice to be executed after a join point completes normally: for example, if a method returns without throwing an exception.

• After throwing advice: Advice to be executed if a method exits by throwing an exception.

• After (finally) advice: Advice to be executed regardless of the means by which a join point exits (normal or exceptional return).

为此，我拿aspectj的工具写了测试代码，如下：

public class Boss {

    public static void main(String[] args) {
        Boss boss = new Boss();
        boss.meeting();
    }

    public void meeting() {
        System.out.println("The boss is in a meeting");
    }

}


public aspect BossAspect{
	//定义切点
    pointcut bossPoint() : execution(* meeting(..));
	
    //前置通知，对切点增强
	before() : bossPoint(){
		System.out.println("before advise");
	}

	//after通知
	after() : bossPoint(){
		System.out.println("after advise");
	}

	//after returning通知
	after() returning: bossPoint(){
		System.out.println("after returning advise");
	}
	
}

然后执行如下命令编译：

./ajc ../src/*.java -injars /Users/tt0008641/IdeaProjects/aspectj/lib/aspectjrt.jar

然后对生成的Boss.class反编译，得到如下结果：

public class Boss {
    public Boss() {
    }

    public static void main(String[] args) {
        Boss boss = new Boss();
        boss.meeting();
    }

    public void meeting() {
        try {
            BossAspect.aspectOf().ajc$before$BossAspect$1$7ba14e64();
            System.out.println("The boss is in a meeting");
        } catch (Throwable var2) {
            BossAspect.aspectOf().ajc$after$BossAspect$2$7ba14e64();
            throw var2;
        }

        BossAspect.aspectOf().ajc$after$BossAspect$2$7ba14e64();
        BossAspect.aspectOf().ajc$afterReturning$BossAspect$3$7ba14e64();
    }
}

 可以看到，最后两行代码就是Aspectj为我们添加的代码，一个是AfterAdvise的织入代码，一个是AfterReturning织入的代码。他们都没有放入finally块中，换句话说没有finally块。他们都是在被代理方法执行完成之后执行的，只是after织入方法先被执行，after returning后被执行。而且通过反编译代码可以发现，如果有异常，在catch块中接着继续抛出异常，after和afterreturning的方法（上边最后两行）代码都不被执行。

当然在Spring中，并没有使用Aspect 的编译器来编译，而只是借鉴了他的语法，同时使用jdk动态代理或者cglib的方式来生成代理对象，至于生成的对象长什么样子，被代理的方法和各种织入的代码之间的执行顺序，大家有兴趣可以继续深入探讨一下（由于spring是直接在内存中生成代理对象的字节码，我们没办法找到对应的文件进行反编译哈），我看网上有的文章说当异常发生时，所有的织入代码都会被执行，顺序是这样的顺，对此保持怀疑啊，大家有兴趣可以继续研究下：

有异常的情况

@Around start
@Before...
method invoke
@After...
@AfterThrowing...  

try{
    try{
        //@Around start
        //@Before
        method.invoke(..);
        //@Around end
    }finally{
        //@After
    }
    //@AfterReturning
}catch(){
    //@AfterThrowing

after的算法书的遗落在一个叫做AIJ的迷宫中了，这个迷宫有N*M个房间，迷宫的入口为(1，1)，算法书遗落在(r，c)。迷宫中的房间有四种状态：空房间、无法进入的房间、有墨菲斯托存在的房间和有莉莉丝存在的房间。墨菲斯托会否定一切，而莉莉丝会诱惑人做一种叫做YK的活动。after是一个意志薄弱的人，他遇到了墨菲斯托和莉莉丝之后，便会变成眼神空洞的超级YK机器人。after每步可以从他当前的房间走至上下左右四个房间的其中一个房间。after害怕变成超级YK机器人，所以要尽快拿到算法书然后从入口逃离。问after最少需要走多少步才可以在不变成超级YK机器人的情况下从入口出发取回算法书并逃离迷宫？

输入描述:
第一行一个正整数T(T<=10)，表示共有T组数据。
对于每组数据，第一行四个正整数N，M，r，c(1<=N,M<=1000；1<=r<=N；1<=c<=M)。
接下来N行，每行M个字符，每个表示房间的状态，“.”表示空房间，“*”表示无法进入的房间，“F”表示有墨菲斯托存在的房间，“M”表示有莉莉丝存在的房间。
数据保证(1，1)为“.”。

输出描述:
对每组数据输出一行，即after最少需要走的步数。若after无法取回算法书，则输出“IMPOSSIBLE”(不带引号)。
示例1
输入
1
4 4 4 3
…**
*F…
..
*M.F
输出
14

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
const int INF = 2e9;
struct Node
{
    int x, y, dis;
}q[N * N];
char s[N][N], ts[N][N];
int n, m, r, c;
int dx[4] = {0, -1, 0, 1};
int dy[4] = {-1, 0, 1, 0};
int bfs()
{
    int hh = 0, tt = -1;
    q[++tt] = (Node){1, 1, 0};
     
    while(hh <= tt)
	{
        Node t = q[hh++];
        if(t.x == r && t.y == c) return t.dis * 2;
        for(int i = 0; i < 4; i++)
		{
            int x = dx[i] + t.x, y = dy[i] + t.y;
            if(x >= 1 && x <= n && y >= 1 && y <= m && ts[x][y] == '.')
			{
                ts[x][y] = '*';
                q[++tt] = {x, y, t.dis + 1};
            }
        }
    }
    return INF;
}
void solve()
{
    scanf("%d%d%d%d", &n, &m, &r, &c);
    for(int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            ts[i][j] = (s[i][j] == 'F' ? '.' : s[i][j]);
    int res = bfs();
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            ts[i][j] = (s[i][j] == 'M' ? '.' : s[i][j]);
    res = min(res, bfs());
    if(res == INF) puts("IMPOSSIBLE");
    else printf("%d\n", res);
}  
int main()
{
    int T = 1;
    scanf("%d", &T);
    while(T--)
        solve();
    return 0;
}