Mybatis流式查询之ResultHanlde

0.前言

正常访问数据库的查询操作，都是根据查询sql一次性返回查询结果。
但如果遇到目标数据量过大、且需要全量查询、不能分页、或者内存不想被返回的结果占用过多等需求时(例如导出excel)，就可能需要流式查询。

1.准备工作

1.1.Mybaits的jar包引入

注：idea必须配置build，否则扫描不到src下的xml文件

    
        relife
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    relife-object
    
        
        
            log4j
            log4j
            1.2.17
        
        
            junit
            junit
            4.12
            compile
        
        
            cglib
            cglib
            2.2
        
        
            mysql
            mysql-connector-java
            8.0.20
        

        
        
            org.mybatis
            mybatis
            3.4.6
        

    
    
        
            
                src/main/java
                
                    **/*.xml
                
            
        
    

1.2.实体类User

public class User {
    private String name;
    private int age;
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

1.3.mybatis-config.xml和userMapper.xml

mybatis-config.xml（resource根目录）

userMapper.xml

    
		select id,name,age from user
	

2.流式处理

2.1流式逐条处理handle

public class UserResultHandler implements ResultHandler {

    @Override
    public void handleResult(ResultContext resultContext) {
        // 这里获取流式查询每次返回的单条结果
        User user = resultContext.getResultObject();
        handle(user);
    }
   // 串行逐条执行handle
    private void handle(User user) {
        System.out.println(user.getId());
    }
}

适用于导出excel等,，上述写法缺点也很明显，单线程，串行，所有效率慢，但是类似导出excel，符合要求，也不太方便使用多线程。

2.2.流式批量多线程处理handle

为了解决效率问题，有时候会对结果有比如发送请求，更行其他内容等需求时

public class UserResultHandler implements ResultHandler {
    public final Logger logger = Logger.getLogger(this.getClass());
    /**
     * 线程池线程数
     */
    private int threadPollNum = 100;

    public UserResultHandler() {
    }

    public UserResultHandler(int threadPollNum) {
        this.threadPollNum = threadPollNum;
    }

    // 线程池
    public ExecutorService executorService = Executors.newFixedThreadPool(threadPollNum);
    // 线程执行结果
    public List futureList = new ArrayList<>();

    @Override
    public void handleResult(ResultContext resultContext) {
        // 这里获取流式查询每次返回的单条结果
        T user = resultContext.getResultObject();
        while (futureList.size() > 200) {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            futureList = futureList.stream().filter(future -> !future.isDone()).collect(Collectors.toList());
            logger.info("条数：" + resultContext.getResultCount() + "->未完成结果" + futureList.size());
        }

        UserThread ut = new UserThread(user);
        Future future = executorService.submit(ut);
        futureList.add(future);
    }

    /**
     * 保证所有线程执行完成，并关闭线程池
     */
    public void end() {
        while (futureList.size() != 0) {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            futureList = futureList.stream().filter(future -> !future.isDone()).collect(Collectors.toList());
        }
        executorService.shutdown();
    }

    public static class UserThread implements Runnable {
        private T obejct;

        public UserThread(T obejct) {
            this.obejct = obejct;
        }

        @Override
        public void run() {
            System.out.println(((User)obejct).getId());
        }

        public T getObejct() {
            return obejct;
        }

        public void setObejct(T obejct) {
            this.obejct = obejct;
        }
    }

}

上述写法，可用于需要线程返回值的，或者明确需要线程执行完成，且可以保证不占用过多内存。其中Thread.sleep（）方法，可以自定义时间。

3.测试

3.1.测试案例

public static void main(String[] args) throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        System.out.println("sqlSessionFactory:" + sqlSessionFactory);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 正常查询
        List userList5 = sqlSession.selectList("selectUser");
        // 流式查询
        UserResultHandler userResultHandler = new UserResultHandler(100);
        sqlSession.select("selectUser", userResultHandler);
        userResultHandler.end();
        sqlSession.close();
    }

3.1.正常查询debug调用

调用图

3.2.流式查询debug调用

调用图

4.问题与部分源码解析

4.1加入resulthandle为什么会流式查询？

在DefaultResultSetHandler类中handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List multipleResults, ResultMapping parentMapping) throws SQLException 方法中出现了调用区别一个303行，一个206行

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List