Java数据库处理性能建议

我正在开发一个Java应用程序，它从oracle数据库表中读取记录，并在读取每条记录后进行一些处理。 注意：应用程序只从数据库中读取数据，不写回任何内容

我使用的是标准的jdbc驱动程序、连接、准备好的语句和结果集。 我需要获取的记录数大约为500000（最多）

我当前的实现：

我已将语句获取大小设置为500。（查询是一个表中的简单select语句） 在读取每个结果集记录时，我将每个记录添加到java集合中，如下所示：

        List<HashMap<String,String>> userData=new ArrayList<HashMap<String,String>>();
        ResultSetMetaData resultSetMetData = resultSet.getMetaData();
        while(resultSet.next()){
            HashMap<String,String> recordMap = new HashMap<String,String>();
            for (int i = 1; i <= resultSetMetData.getColumnCount(); i++) {
                String key = resultSetMetData.getColumnName(i);
                String value = resultSet.getString(key);
                recordMap.put(key, value);
            }
            userData.add(recordMap);
        }

List userData=new ArrayList（）；
ResultSetMetaData ResultSetMetaData=resultSet.getMetaData（）；
while（resultSet.next（））{
HashMap recordMap=新的HashMap（）；
对于（int i=1；i这个问题的答案取决于SQL查询与需要进行的API调用相比的相对速度，以及与记录的大小和数量相比的内存量

如果不知道这些，很难知道

如果API调用相对较慢且内存充足：

创建一个包含多个优化线程的
查询您的数据库，并将每一行逐一发送给executor执行
如果查询速度相对较慢或内存不足：

将select语句划分为8个查询，每个查询返回数据的不同部分
创建8个线程
每个线程运行一个查询，并在Oracle返回每一行时调用API
你也应该整理你的收藏品

1-如果您事先知道您的列表将非常大，您可以使用
阵列列表容量

默认情况下，ArrayList的初始容量为10条记录。当您的列表增长时，java将连续（少量）重新分配列表，从而浪费大量时间

  List<HashMap<String,String>> userData=new ArrayList<HashMap<String,String>>(500);

TestObj是一个只包含名为test1…test25的公共字段的对象。为了简单和快速，我将它们公开，在现实世界中，您可以将它们私有化。它可以进行更严格的设计，但我很快就完成了

这里是精化的输出

EXAMPLE WITH HASHMAP, useCapacity=false, loops=200000
Wed Feb 15 06:04:48 CET 2017 time: 1487135088903 Start for loops=200000 and useCapacity=false
Wed Feb 15 06:04:55 CET 2017 time: 1487135095922, elapsed=7019 end for loops=200000 and useCapacity=false
-------------------------
EXAMPLE WITH HASHMAP, useCapacity=true, loops=200000
Wed Feb 15 06:04:55 CET 2017 time: 1487135095922 Start for loops=200000 and useCapacity=true
Wed Feb 15 06:05:01 CET 2017 time: 1487135101073, elapsed=5151 end for loops=200000 and useCapacity=true
-------------------------
EXAMPLE WITH CLASSIC OBJECT, useCapacity=false, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101073 Start for loops=200000, object and useCapacity=false
Wed Feb 15 06:05:01 CET 2017 time: 1487135101254, elapsed=181 end for loops=200000, object and useCapacity=false
-------------------------
EXAMPLE WITH CLASSIC OBJECT, useCapacity=true, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101254 Start for loops=200000, object and useCapacity=true
Wed Feb 15 06:05:01 CET 2017 time: 1487135101274, elapsed=20 end for loops=200000, object and useCapacity=true
-------------------------
EXAMPLE WITH REFLECTION, useCapacity=false, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101274 Start for loops=200000, object and useCapacity=false
Wed Feb 15 06:05:05 CET 2017 time: 1487135105562, elapsed=4288 end for loops=200000, reflect and useCapacity=false
-------------------------
EXAMPLE WITH REFLECTION, useCapacity=true, loops=200000
Wed Feb 15 06:05:05 CET 2017 time: 1487135105562 Start for loops=200000, object and useCapacity=true
Wed Feb 15 06:05:09 CET 2017 time: 1487135109711, elapsed=4149 end for loops=200000, reflect and useCapacity=true
-------------------------

正如您将看到的，使用容量将hashmap示例从大约7秒增加到5.1秒

以经典方式使用对象会使阵列中的容量达到181毫秒（！），甚至20毫秒（！！）

通过使用容量（4288 vs 4149），反射性能可以独立地达到4秒左右

请注意，基准测试的准确时间可能因执行而异。但一般来说，时间顺序总是相同的

关于在“块”中获取记录，这是一个很好的内存一致性解决方案，特别是当您的细化可能很长的时候。通常长时间运行的查询可能会出现“快照太旧”错误，这可能会产生问题。而且也不确定性能是否会因此而降低很多。
在过去，我必须处理类似的问题，一个非常好的解决方案是在字段中添加“chunk\u id”，在源表中使用索引，这使得重复我对“下一个”行的查询变得很容易，并且比检索表中的所有内容更高效。通常，您只需要找到一种方法来标识组1、组2……组n中的记录组（当然，还要将索引放在那里）

PS反射的例子很简单，但它只是演示如何做，你可以使用许多功能，包括方法等
如果你将所有200000行保存在一个列表中，那么它将占用大量内存。你对数据做什么？它不能以你需要的格式进行
选择
it@ScaryWombat不，我需要做一些程序基于每条记录进行essing。如果在列表中添加所有行需要占用大量内存，建议在我处理所有记录之前将resultset保持打开这么长时间？即使我说
占用大量内存
，这对你来说可能不是问题。你真的面临任何问题吗？@ScaryWombat到目前为止还不是问题，但我们还没有投入使用h我们的应用程序。我只是想确保我使用了正确的方法。一个问题：如果我将fetch size设置为500，并且在读取每500条记录之后，我生成一个线程来处理500条记录，你认为这是一个advatange还是变得复杂？需要做什么样的处理？如果你可以将处理逻辑移到数据，而不是移动所有数据？谢谢你的回答。在第2点上，我可以创建一个对象来封装我的结果集列。但我有一个问题。目前我从DB获取的列是可配置的，如果我有一个对象，我失去了在这种情况下的灵活性，你就不能这样做，我相信。但这取决于当然，您可以拥有配置。您的表真的变化很大吗？实际上它永远不会改变，只有配置映射可能会改变，简而言之，我需要将表列映射到一些内部字段，这是配置，如果我使用对象，我将失去这种灵活性您也可以使用反射。这可能有一点性能上的缺点（但可能比分配成千上万的地图要少得多），还有一点编程上的努力。也许你可以做一个基准测试。如果我今晚有时间，我会给你看一个例子谢谢你的朋友！我会寻找映射字段的反射。当你有时间的时候，请给我指一些链接或一个小例子，谢谢！
EXAMPLE WITH HASHMAP, useCapacity=false, loops=200000
Wed Feb 15 06:04:48 CET 2017 time: 1487135088903 Start for loops=200000 and useCapacity=false
Wed Feb 15 06:04:55 CET 2017 time: 1487135095922, elapsed=7019 end for loops=200000 and useCapacity=false
-------------------------
EXAMPLE WITH HASHMAP, useCapacity=true, loops=200000
Wed Feb 15 06:04:55 CET 2017 time: 1487135095922 Start for loops=200000 and useCapacity=true
Wed Feb 15 06:05:01 CET 2017 time: 1487135101073, elapsed=5151 end for loops=200000 and useCapacity=true
-------------------------
EXAMPLE WITH CLASSIC OBJECT, useCapacity=false, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101073 Start for loops=200000, object and useCapacity=false
Wed Feb 15 06:05:01 CET 2017 time: 1487135101254, elapsed=181 end for loops=200000, object and useCapacity=false
-------------------------
EXAMPLE WITH CLASSIC OBJECT, useCapacity=true, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101254 Start for loops=200000, object and useCapacity=true
Wed Feb 15 06:05:01 CET 2017 time: 1487135101274, elapsed=20 end for loops=200000, object and useCapacity=true
-------------------------
EXAMPLE WITH REFLECTION, useCapacity=false, loops=200000
Wed Feb 15 06:05:01 CET 2017 time: 1487135101274 Start for loops=200000, object and useCapacity=false
Wed Feb 15 06:05:05 CET 2017 time: 1487135105562, elapsed=4288 end for loops=200000, reflect and useCapacity=false
-------------------------
EXAMPLE WITH REFLECTION, useCapacity=true, loops=200000
Wed Feb 15 06:05:05 CET 2017 time: 1487135105562 Start for loops=200000, object and useCapacity=true
Wed Feb 15 06:05:09 CET 2017 time: 1487135109711, elapsed=4149 end for loops=200000, reflect and useCapacity=true
-------------------------