方案一：

        用k8s提供的continue指定起始位，用limit 指定每次返回数据量

优点：代码简单，易操作

缺点：1、continue参数失效，暂时没有找到原因；2、没有数据量总数，无法分页

方案二（推荐）：

        利用k8s的informer机制，对数据监控，当数据有变化时，会回调不同事件的方法,更新数据库，这样就可以利用数据库的特性，实现分页查询

public class InformerExample {
  public static void main(String[] args) throws Exception {
      CoreV1Api coreV1Api = new CoreV1Api();
      ApiClient apiClient = coreV1Api.getApiClient();
      // 可以根据自己需求创建client，我自己创建的是httpsClient,这里先用http请求，需要https请求的可以直接百度，OkHttpClient https 
      OkHttpClient httpClient =
              apiClient.getHttpClient().newBuilder().readTimeout(0, TimeUnit.SECONDS).build();
      apiClient.setHttpClient(httpClient);

      SharedInformerFactory factory = new SharedInformerFactory();

      // Node informer
      SharedIndexInformer<V1Node> nodeInformer =
              factory.sharedIndexInformerFor(
                      // 注意：这三个不是null的参数是传过来的，必须要用起来
                      (CallGeneratorParams params) -> {
                          return coreV1Api.listNodeCall(
                                  null,
                                  null,
                                  null,
                                  null,
                                  null,
                                  null,
                                  params.resourceVersion,
                                  null,
                                  params.timeoutSeconds,
                                  params.watch,
                                  null);
                      },
                      V1Node.class,
                      V1NodeList.class);

      nodeInformer.addEventHandler(
              new ResourceEventHandler<V1Node>() {
                  @Override
                  public void onAdd(V1Node node) {
                      // TODO 更新数据库，注意：每次程序启动，所有的资源都会重新回调这个方法，
                      // 也就是说，程序启动，就会把已经存在于服务器上的资源全部查询出来，然后回调这个方法/onUpdate
                      System.out.printf("%s node added!\n", node.getMetadata().getName());
                  }

                  @Override
                  public void onUpdate(V1Node oldNode, V1Node newNode) {

                      // TODO 更新数据库，注意：每次程序启动，所有的资源都会重新回调这个方法，
                      // 也就是说，程序启动，就会把已经存在于服务器上的资源全部查询出来，然后回调这个方法/onAdd
                      System.out.printf(
                              "%s => %s node updated!\n",
                              oldNode.getMetadata().getName(), newNode.getMetadata().getName());
                  }

                  @Override
                  public void onDelete(V1Node node, boolean deletedFinalStateUnknown) {
                      
                      System.out.printf("%s node deleted!\n", node.getMetadata().getName());
                  }
              });

      factory.startAllRegisteredInformers();

      V1Node nodeToCreate = new V1Node();
      V1ObjectMeta metadata = new V1ObjectMeta();
      metadata.setName("noxu");
      nodeToCreate.setMetadata(metadata);
      V1Node createdNode = coreV1Api.createNode(nodeToCreate, null, null, null);
      Thread.sleep(3000);

      Lister<V1Node> nodeLister = new Lister<V1Node>(nodeInformer.getIndexer());
      V1Node node = nodeLister.get("noxu");
      System.out.printf("noxu created! %s\n", node.getMetadata().getCreationTimestamp());
      factory.stopAllRegisteredInformers();
      Thread.sleep(3000);
      System.out.println("informer stopped..");
  }
}

ps：大家如果有更好的解决方案可以留言哈