java 46 lines · 8 steps

Rebuilding a search index at Spring startup

An ApplicationRunner streams every active product and writes it into a search view in fixed-size batches when the app boots.

Explained by highlit

Spring Intermediate startup-hook batching streaming search-index dependency-injection

1@Component
2@Order(20)
3public class ProductSearchIndexRunner implements ApplicationRunner {
4 
  private static final Logger log = LoggerFactory.getLogger(ProductSearchIndexRunner.class);
6 
  private final ProductRepository products;
  private final ProductSearchView searchView;
9 
  public ProductSearchIndexRunner(ProductRepository products, ProductSearchView searchView) {
      this.products = products;
      this.searchView = searchView;
  }
14 
  @Override
  public void run(ApplicationArguments args) {
      if (args.containsOption("skip-index")) {
          log.info("Skipping product search index rebuild (--skip-index present)");
          return;
      }
21 
      StopWatch watch = new StopWatch();
      watch.start();
      searchView.clear();
25 
      int indexed = 0;
      try (Stream<Product> stream = products.streamAllActive()) {
          List<ProductDocument> batch = new ArrayList<>(500);
          for (Product product : (Iterable<Product>) stream::iterator) {
              batch.add(ProductDocument.from(product));
              if (batch.size() == 500) {
                  searchView.saveAll(batch);
                  indexed += batch.size();
                  batch.clear();
              }
          }
          if (!batch.isEmpty()) {
              searchView.saveAll(batch);
              indexed += batch.size();
          }
      }
42 
      watch.stop();
      log.info("Rebuilt product search index: {} documents in {} ms", indexed, watch.getTotalTimeMillis());
  }
46}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1ApplicationRunner lets you run one-off work after the context is ready, ordered against other runners.
2Streaming rows and flushing in fixed-size batches keeps memory flat over large datasets.
3A command-line flag gives operators an escape hatch to skip expensive startup work.

Related explainers

java

public final class FileChecksum {
 
    private static final char[] HEX = "0123456789abcdef".toCharArray();

Streaming a SHA-256 file checksum in Java

hashing streams resource-management

Intermediate 7 steps

typescript

import { Injectable, signal, computed } from '@angular/core';
import {
  HttpInterceptorFn,
  HttpContextToken,

Tracking HTTP loading state in Angular

signals http-interceptor reference-counting

Intermediate 8 steps

javascript

const express = require('express');
const compression = require('compression');
const zlib = require('zlib');

Tuning Express response compression

compression middleware http

Intermediate 9 steps

python

from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel, ConfigDict, EmailStr
from sqlalchemy.orm import Session

Building a users router in FastAPI

routing serialization dependency-injection

Intermediate 7 steps

typescript

type Event = Record<string, unknown>;
 
interface BatcherOptions {
  endpoint: string;

Batching analytics events in TypeScript

batching buffering async

Intermediate 8 steps

java

@Service
public class OrderCheckoutService {
 
    private final OrderRepository orderRepository;

How @Transactional guards a Spring checkout

dependency-injection transactions atomicity

Intermediate 6 steps

Share this explainer

Here's the card — post it anywhere.

Rebuilding a search index at Spring startup — share card

Made with highlit — turn any snippet into a walkthrough like this in about a minute.

Explain your code