In this post, I'll share how we solved both using a Generic Specification Repository and Slice-based Pagination.

1. The Problem: Boilerplate & Heavy Queries

The Boilerplate Trap

Typically, allowing users to filter by name, status, createdDate, etc., requires writing endless custom repository methods or complex CriteriaBuilder logic.

The Count Query Killer

Standard pagination (Page<T>) executing findAll(Pageable) triggers two queries:

1. The actual data query (SELECT ... LIMIT ? OFFSET ?).

2. A total count query (SELECT COUNT(*) ...).

For large tables, the count query is a performance killer. If you're building an "Infinite Scroll" or "Load More" feature, you don't even need the total count—you just need to know if there's a "next page".

2. The Solution: Generic Specification Repository

We implemented a wrapper around JpaSpecificationExecutor that accepts a dynamic SearchRequest. This allows us to filter any entity without writing custom query code.

The Interface

@NoRepositoryBean
public interface SpecificationRepository<T, ID> extends JpaRepository<T, ID>, SliceSpecificationExecutor<T> {    
    // Inherits findAll(Specification<T>, Pageable)    
    // Inherits findAllSliced(Specification<T>, Pageable)
}

The Usage

Now, any repository can extend this and instantly gain dynamic search powers:

public interface ThreatActorRepository extends SpecificationRepository<ThreatActor, UUID> {}

The Service layer simply builds the specification from a JSON request:

public Page<ThreatActor> search(SearchRequest request) {    
    Specification<ThreatActor> spec = GenericSpecificationBuilder.buildFromRequest(request);    
    return repository.findAll(spec, pageable);
}

3. The Optimization: Slice vs. Page

To solve the count query performance issue, we implemented SliceSpecificationExecutor.

What is a Slice?

A Slice in Spring Data holds a chunk of data and knows if there is a next slice (hasNext()), but it does not know the total number of pages.

Implementing findAllSliced

We leveraged Spring Data's Window API (introduced recently) to fetch results efficiently:

SliceSpecificationExecutor.javadefault Slice<T> findAllSliced(Specification<T> spec, Pageable pageable) {    // Uses a "Window" to fetch size + 1 items to determine if a next page exists    // completely avoiding the SELECT COUNT(*) query.    Window<T> window = this.findBy(spec, ...);    return new SliceImpl<>(window.getContent(), pageable, window.hasNext());}

The Performance Win

By switching from /search (Page) to /search-sliced (Slice), we eliminate the heavy count query entirely.

SQL Comparison:

Regular Page Request:

sqlHibernate: select ... from threat_actors limit ? offset ?Hibernate: select count(*) from threat_actors ... -- 🛑 EXPENSIVE on large tables

Slice Request:

sqlHibernate: select ... from threat_actors limit ? offset ? -- ✅ ONLY ONE QUERY

4. Conclusion

By combining the Specification Pattern with Slice Pagination, we achieved:

1. Cleaner Code: Zero boilerplate for dynamic filters.

2. Better Performance: 50% fewer queries for infinite scroll views.

Check out the full implementation in the repository!

References

• https://github.com/prasadgaikwad/spring-data-jpa-specification

• https://gist.github.com/josergdev/06c82891a719eca4834410339885ad23

• Spring Data JPA Specifications

• Vlad Mihalcea: The best way to use the Spring Data JPA Specification

What is LangChain4j?

LangChain4j is a powerful Java framework designed to simplify the development of applications powered by Large Language Models (LLMs). It provides a comprehensive set of tools and abstractions that make it easier to build sophisticated AI-powered applications.

Project Setup

Prerequisites

• Java 17 or higher

• Maven

• Your favorite IDE (IntelliJ IDEA, Eclipse, or VS Code)

• An API key from your chosen LLM provider (e.g., OpenAI)

Step 1: Create a Spring Boot Project

Start by creating a new Spring Boot project using Spring Initializr or your IDE. We'll need the following dependencies:

• Spring Boot Starter

• LangChain4j BOM (Bill of Materials)

Here's our pom.xml configuration:

<!-- Parent Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.5.7</version>
</parent>

<!-- LangChain4j BOM for version management -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-bom</artifactId>
            <version>1.8.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- LangChain4j OpenAI Integration -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
    </dependency>
</dependencies>

Step 2: Configuration

Create or update your .env file: (make sure to add this .env file to your .gitignore to keep your API key secure)

# OpenAI API Configuration
OPENAI_API_KEY=your-api-key-here

Step 3: Creating the Application

We'll create a simple command-line application that:

1. Asks for user's question

2. Answers concisely using the OpenAI GPT-4o-mini model

3. Continues interaction until they type 'quit'

The implementation uses Spring's CommandLineRunner for the interactive loop.

Understanding the Code

Let's break down the key components:

1. The Main Application Class

@SpringBootApplication
public class LangChain4jDemoApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication.run(LangChain4jDemoApplication.class, args);
    }

    /**
     * A simple command-line application that interacts with the user,
     * takes a question as input, and provides a concise answer using
     * the OpenAI GPT-4o-mini model.
     */
    @Override
    public void run(String... args) {
        ChatModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o-mini")
                .build();

        try (Scanner scanner = new Scanner(System.in)) {
            while (true) {
                System.out.print("Please enter your question (type 'quit' to exit): ");
                String question = scanner.nextLine();

                if ("quit".equalsIgnoreCase(question)) {
                    System.out.println("Goodbye!");
                    break;
                }

                String response = model.chat("You are an helpful assistant. " +
                        "Answer this question in very concise way, only in 2 sentences maximum. Question: " + question);
                System.out.println("Answer: " + response);
                System.out.println(); // Add a blank line for better readability
            }
        }
    }
}

Running the Application

To run the application:

1. Ensure you have set your API key in .env file

2. Run the following command:

    ./mvnw spring-boot:run
   

Next Steps

This basic setup provides a foundation for exploring more advanced LangChain4j features:

1. Adding LLM Integration

   • Implement chat completions

   • Add streaming responses

   • Experiment with different models

2. Implementing Memory

   • Add conversation history

   • Implement different memory types

3. Creating Chains

   • Build processing pipelines

   • Add prompt templates

Resources

For more information and advanced features, check out:

• Official LangChain4j Documentation

• GitHub Examples Repository

Conclusion

This simple example demonstrates how easy it is to get started with LangChain4j. The framework's integration with Spring Boot makes it particularly attractive for Java developers looking to build AI-powered applications.

Stay tuned for more blog posts where we'll explore advanced features like:

• Working with different LLM providers

• Implementing RAG (Retrieval Augmented Generation)

• Building custom agents and tools

• Creating sophisticated conversation chains

Remember to check out our GitHub repository for the complete source code and future updates!

Note: The steps mentioned here are specifically for Google DNS, a .dev domain and Hashnode.

So I wanted to create my blog and online profile for quite some time but was not sure about following:

1. How to start the blog?
2. How to register a domain name and setup?
3. Should I use any blogging platform or build my own blog?
4. Which blogging platform to use?

And after researching for a while, I decided to create my blog today to check this item off my list on very first day of the year :)

Here is a short tutorial on how to create a blog, setup your own domain name and use the domain name to redirect to your blog, all about in 10 minutes. (off course it took some time for me to research on the options for blogging platforms, domain name service providers etc, but actual process of blog setup took about 10 minutes!)

My Choices

• I chose Google Domains as my domain name service (DNS) provider to avoid getting too much into the weeds for searching a DNS provider. During my initial research, I found it has features which I required to get started quickly.
• I picked Hashnode as my blogging platform since I found that it provides a lot of useful features in addition to the ease of creating and maintaining a blog.

Prerequisites

1. You need a google/gmail account to buy domain name from google.
2. Create an account with Hashnode to get you started (you don't need steps for this, believe me ;))

Steps

1. Search for your required domain name at Google Domains, add it to the cart and proceed. You should see something like following on next screen:
2. Provide required contact information on checkout screen.
3. Provide payment information and checkout. That's it! You own the domain name now! You may have to verify your email address for the domain purchase.
4. On your Hashnode blog dashboard page, add your domain name (in my case I used a subdomain blog.prasadgaikwad.dev) under DOMAIN tab and click update. You will see next steps on the same page as shown below:
5. Go back to your Google Domains dashboard and select the newly created domain name to go into its settings.
6. Go to DNS section and scroll to the "Custom resource records" section. Add CNAME record as shown below: (Note that I am using a subdomain "blog" since Google Domains does not support CNAME record for root domain. You can create any subdomain)
7. Wait for few minutes and go to your subdomain url, you should see your Hashnode blog!
8. Wait for it...you may also want to redirect your root domain (in my case prasadgaikwad.dev and www.prasadgaikwad.dev), then go the Website section of your Google Domains page and add Forward domain details. (In my case I forwarded my root domain to my blog subdomain for now!)
9. You may have to hard refresh (command + r) browser page with your domain url, to delete any cached pages or errors.
10. And that's all you need to get your own developer blog started on your custom domain.

References:

1. How to Set Up a Custom Domain on Devblog
2. Hashnode: How to Launch Your Own Developer Blog on Your Own Domain in Minutes

(I created this blog post to document steps which I could not find in reference blogs, so that it might be useful if someone decides to use these platforms like me)