Baeldung

Java Weekly, Issue 644

baeldung — Fri, 01 May 2026 08:59:37 +0000

1. Spring and Java

>> Avoiding Final Field Mutation [inside.java]

JDK 26 starts warning when reflection mutates final fields, which is definitely a quiet but meaningful step toward the JVM actually enforcing what final has always promised.

2. Technical & Musings

>> Vibing, Harness and OODA loop [event-driven.io]

A sharp framing of why “vibe coding” with LLMs feels productive but often isn’t.

Also worth reading:

>> ESP32 time bootstrap problem [advancedweb.hu]
>> Before GitHub [pocoo.org]
>> Equity for Europeans [pocoo.org]
>> Thoughts on AI, Databases, and Conferences as of April 2026 [ozar.me]
>> Structured-Prompt-Driven Development (SPDD) [martinfowler.com]
>> What’s Missing in the ‘Agentic’ Story [mnot.net]
>> Responsibility is the Human Moat [satisfice.com]
>> Scaling Camera File Processing at Netflix [netflixtechblog.com]
>> The Big Mac Coding Era [dandreamsofcoding.com]

3. Pick of the Week

>> How good engineers write bad code at big companies [seangoedecke.com]

The post Java Weekly, Issue 644 first appeared on Baeldung.

IntelliJ Series

baeldung — Thu, 30 Apr 2026 18:18:17 +0000

IntelliJ IDEA is the leading IDE for Java and JVM development, combining intelligent code analysis, deep framework integration, and powerful tooling into a single environment. From quick-fixes and refactoring to remote debugging and plugin development, mastering IntelliJ means spending less time on tooling and more on solving actual problems.

This series covers practical IntelliJ IDEA workflows from setup to advanced development, organized by task: from configuring the IDE and managing projects, through coding productivity features, debugging applications locally and remotely, and navigating codebases with built-in analysis tools.

IDE Setup and Configuration

Project and Build Management

Coding and Editing

Debugging

The post IntelliJ Series first appeared on Baeldung.

Jakarta EE Series

baeldung — Thu, 30 Apr 2026 18:07:58 +0000

Jakarta EE (formerly Java EE) is the standard enterprise Java platform, providing a comprehensive set of specifications for building scalable, multi-tier server-side applications. It covers the full stack from web tier components like Servlets and JSP to enterprise services like CDI and EJB, along with robust support for RESTful and SOAP web services.

This series covers core Jakarta EE APIs in practical application, organized by concern: from setting up and deploying applications on Jakarta EE servers, through building the web tier with servlets and view technologies, designing service layers with JAX-RS and JAX-WS, enforcing contracts with Bean Validation, and managing enterprise components with CDI and EJB.

Jakarta EE Platform and Core Concepts

Servlets

JSP and JSF

Web Services: JAX-RS and JAX-WS

Bean Validation

CDI and EJB

The post Jakarta EE Series first appeared on Baeldung.

Java Maps Series

baeldung — Thu, 30 Apr 2026 08:12:05 +0000

The Map interface is one of Java’s most powerful data structures, enabling fast key-value lookups with a range of implementations suited to different needs. From the general-purpose HashMap to the ordered TreeMap, insertion-ordered LinkedHashMap, and thread-safe ConcurrentHashMap, choosing the right map type and using it correctly is a core Java skill.

This series covers practical Map operations from fundamentals to advanced patterns, organized by task: from picking the right implementation and initializing maps, through reading and modifying entries, iterating and streaming, sorting and comparing, and converting maps to and from other types.

Map Implementations

Creating and Initializing Maps

Reading, Updating, and Removing Entries

Iterating and Streaming Maps

Sorting, Searching, and Comparing Maps

Converting Maps

The post Java Maps Series first appeared on Baeldung.

Java List Series

baeldung — Thu, 30 Apr 2026 07:50:21 +0000

The List interface is one of Java’s most essential collection types, offering ordered, index-based access to elements with flexible implementations including ArrayList and LinkedList. Understanding how to create, search, sort, and transform lists is a core skill for any Java developer.

This series covers practical List operations from the ground up, organized by task: from picking the right implementation and initializing lists efficiently, through modifying elements, iterating and sorting, finding and filtering, and converting between collection types.

List Types and Fundamentals

Creating and Initializing Lists

Adding, Removing, and Modifying Elements

Iterating and Sorting Lists

Searching and Filtering Lists

Converting Lists

The post Java List Series first appeared on Baeldung.

Store Java Objects in HttpSession

Sourov Jajodia — Thu, 30 Apr 2026 00:07:54 +0000

1. Introduction

When developing Java-based web applications, there are many situations where we need to maintain user-related data between HTTP requests. HTTP is a stateless protocol and does not maintain any information between requests. This means that each HTTP request is independent and has no prior knowledge of the other requests made for the same session.

In this tutorial, we’ll discuss the basic concepts related to the HttpSession interface in detail. We’ll also discuss the process of storing, retrieving, and deleting Java objects using the key methods provided by the interface, such as setAttribute(), getAttribute(), and removeAttribute().

2. What is HttpSession?

The HttpSession interface is a part of the javax.servlet.http package. It’s used to store a user’s data on the server side between multiple HTTP requests. HTTP is a stateless protocol. HttpSession fills the gap between HTTP’s statelessness and the need to store a user’s data on the server side by providing a unique session to each user.

The servlet container manages the creation of sessions and tracks them using a unique session ID stored as a cookie named JSESSIONID in the client’s browser. We can access a session from any servlet using the getSession() method of the HttpServletRequest object. Let’s see an example of obtaining a session:

HttpSession session = request.getSession();

The request.getSession() method will return the existing active session if one has already been created. Otherwise, it’ll create a brand new one. We can also send the value false as a parameter: request.getSession(false). This allows us to get the existing session without creating a new one. Once we have the session object, we’re ready to start storing data in it.

3. Storing a Java Object in HttpSession

The Java object is stored within a session by means of a setAttribute() method provided by an HttpSession interface. The method takes two parameters: a String key and an object to be stored. This makes it easy to associate any Java object with a key for later retrieval.

Let’s say we have a User class and we want to store a logged-in user’s data in the session. First, here’s our simple User class:

public class User implements Serializable {
    private String username;
    private String email;
    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }
    public String getUsername() { return username; }
    public String getEmail() { return email; }
}

Now, here’s how we store an instance of this object in the session inside a servlet:

protected void doPost(HttpServletRequest request, HttpServletResponse response)
  throws ServletException, IOException {
    User user = new User("john_doe", "john@example.com");
    HttpSession session = request.getSession();
    session.setAttribute("loggedInUser", user);
}

In this example, we first create a new User object with a username and email. Then, we call request.getSession() to obtain the current session. After that, we use session.setAttribute(“loggedInUser”, user) to store the object under the key “loggedInUser”. From this point on, any servlet or JSP in the same session can access this object using that exact key.

4. Retrieving a Java Object from HttpSession

Once we have stored an object in the session, we need a reliable mechanism to access it in the next request. The getAttribute() function provides exactly that purpose. It returns the corresponding object given a key used in the setAttribute() function. And so, it enables us to access the user’s data throughout the entire session.

Building on our previous example, here’s how we retrieve the stored User object in another servlet:

protected void doGet(HttpServletRequest request, HttpServletResponse response)
  throws ServletException, IOException {
    HttpSession session = request.getSession(false);
    private static final Logger logger = LoggerFactory.getLogger(StoreSessionServlet.class);
    if (session != null) {
        User user = (User) session.getAttribute("loggedInUser");
        if (user != null) {
            logger.info("Welcome back, " + user.getUsername());
        } else {
            logger.info("No user found in session.");
        }
    } else {
        logger.info("No active session found.");
    }
}

First, we begin with a call to request.getSession(false) to obtain the current session without accidentally opening a new session. Then, we retrieve the stored object via session.getAttribute(“loggedInUser”), casting it to User. The key point is to always check that it is not null. For example, a session has timed out, or maybe we haven’t yet set the attribute. So, a simple null check is a common pattern to keep our code safe from potential NullPointerException issues.

5. Removing an Object from HttpSession

At some point, we’ll have to clean up the session data that’s no longer required. For example, we clear the user’s details when the user logs out or clear a specific attribute. The HttpSession interface provides two ways of doing it: removeAttribute(), which removes a specific object, and invalidate(), which clears the session.

Here’s how we use both in practice:

protected void doPost(HttpServletRequest request, HttpServletResponse response)
  throws ServletException, IOException {
    HttpSession session = request.getSession(false);
    if (session != null) {
        session.removeAttribute("loggedInUser");
        session.invalidate();
    }
}

In this example, we begin by retrieving the existing session through request.getSession(false). Then, we remove the existing User object we previously stored by calling session.removeAttribute(“loggedInUser”), leaving all other session data intact. session.invalidate() removes the entire session, clearing all the data contained within the session from memory. Moreover, it is important to include a null check to avoid errors when there is no active session.

6. Conclusion

In this article, we’ve discussed how to manage Java objects within an HttpSession using three basic operations: setAttribute to put objects into the session, getAttribute to retrieve objects from the session, and removeAttribute to clean up specific objects from the session. As you can see, we have good control over objects stored within a session and can use this to build stateful, user-aware web applications using the stateless HTTP protocol.

Beyond the basics, we also saw why careful session handling matters. We perform null checks when retrieving attributes and call invalidate() on logout to prevent stale data from lingering on the server. With these fundamentals in place, we’re able to tackle real-world session management challenges and build Java web applications that are both robust and secure.

As always, the full code is available over on Github.

The post Store Java Objects in HttpSession first appeared on Baeldung.

Algorithms in Java Series

baeldung — Wed, 29 Apr 2026 17:40:01 +0000

Algorithms are at the heart of software development, providing foundational solutions to recurring computational problems. From classic sorting routines and graph traversal to advanced optimization and concurrency patterns, a strong grasp of algorithms enables Java developers to write code that is both efficient and correct.

This curated series covers the most important algorithms implemented in Java, organized by topic to guide you from core sorting and searching techniques through graph theory, mathematical computation, string processing, and systems design.

Sorting and Searching

Graph and Tree Algorithms

Array and String Algorithms

Mathematical Algorithms

Optimization and AI Algorithms

Concurrency and Systems Algorithms

The post Algorithms in Java Series first appeared on Baeldung.

Spring AI Series

baeldung — Wed, 29 Apr 2026 08:43:50 +0000

Spring AI is a comprehensive framework for building AI-powered applications on the Spring platform, providing abstractions over language model providers. It enables Java developers to integrate conversational AI, retrieval-augmented generation, and agentic workflows into their applications using familiar Spring patterns.

This curated series provides a practical guide to building AI applications with Spring AI, from core chat and memory concepts to advanced patterns like RAG pipelines, custom advisors, AI agents, and Model Context Protocol (MCP) integration.

Getting Started with Spring AI

AI Models and Providers

RAG and Vector Stores

Advisors and AI Agents

Model Context Protocol (MCP)

Multimodal and Advanced Capabilities

The post Spring AI Series first appeared on Baeldung.

AI in Java Series

baeldung — Wed, 29 Apr 2026 06:59:57 +0000

Artificial intelligence has become a core concern for Java developers, with a growing ecosystem of frameworks and tools for building everything from simple chatbots to sophisticated agentic systems. Java offers strong support for modern AI development through frameworks like Spring AI and LangChain4j, as well as direct integrations with the major LLM providers.

This curated series provides a practical guide to building AI-powered applications in Java, covering foundational concepts, Spring AI’s core features, retrieval-augmented generation, the Model Context Protocol, AI agents, and deep learning libraries.

Getting Started with AI in Java

Building with Spring AI

RAG and Vector Search

Model Context Protocol (MCP)

AI Agents

Deep Learning and ML Libraries

The post AI in Java Series first appeared on Baeldung.

A Guide to @NamedEntityGraph in Hibernate

Amar Wadhwani — Sat, 25 Apr 2026 21:46:41 +0000

1. Overview

JPA provides entity graphs to give us control over entity fetch plans at runtime. However, defining those graphs becomes verbose quickly with deeper association hierarchies.

Hibernate 7 introduces an enhanced Hibernate-specific @NamedEntityGraph annotation (org.hibernate.annotations.NamedEntityGraph) that enables defining entity graphs using a text-based graph language. Instead of nested annotation trees, we define the entity graphs using strings.

In this tutorial, we’ll explore the @NamedEntityGraph annotation, including a few examples of how it works.

2. Setup

Before diving into the usage, let’s prepare the proper environment.

2.1. Hibernate ORM

To use the new annotation, we need the Hibernate ORM dependency (version 7.0 or later):


    org.hibernate.orm
    hibernate-core
    7.3.1.Final
    compile

Next, we set the data model.

2.2. Data Model

Here, we use the blog domain model from the JPA tutorial.

Let’s start with the User entity:

@Entity
@Table(name = "app_user")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    // standard getters and setters
}

The User entity serves as the base class in a single-table inheritance hierarchy.

Next, let’s define an Author, which represents a User who writes posts:

@Entity
public class Author extends User {
    private String bio;
    // standard getters and setters
}

Similarly, we define a Moderator, which represents a User who manages the site:

@Entity
public class Moderator extends User {
    private String department;
    // standard getters and setters
}

Next, we define the Post entity, which has a @ManyToOne association to User and a @OneToMany association to Comment:

@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String subject;
    
    @OneToMany(mappedBy = "post")
    private List comments = new ArrayList<>();
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn
    private User user;
    // standard getters and setters
}

Finally, the Comment entity references both the Post it belongs to and the User who wrote it:

@Entity
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String reply;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn
    private Post post;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn
    private User user;
    // standard getters and setters
}

At this point, we are ready to explore @NamedEntityGraph in practice.

3. Text-Based Graph Language

Hibernate enables the creation of entity graphs by parsing a textual representation of a comma-separated list of attributes and subgraph specifications.

The grammar is fairly straightforward and can be summarized in three points:

simple attributes are comma-separated
subgraphs are enclosed in parentheses
nested subgraphs are supported

Here, we use this syntax to define the named graphs more concisely.

4. Understanding @NamedEntityGraph

Hibernate offers the @NamedEntityGraph annotation as an alternative to the JPA one, and accepts a graph attribute containing a text representation of a fetch plan.

4.1. Simple Graph

To fetch, we list the attributes we want using parentheses for subgraphs:

@NamedEntityGraph(graph = "subject, user, comments(user)")
@Entity
public class Post {
    // ....
}

Compared to the JPA approach, this is a clear and concise way to define the entity graph, which fetches the subject, user, and comments, and for each comment, also fetches its user. Under the hood, Hibernate parses the graph definition and builds the same Entity Graph structure that the JPA annotation tree would produce.

4.2. Defining Multiple Graphs

Hibernate registers the graph using the entity name by default. However, we can also name a graph to distinguish it from the others using the name attribute:

@NamedEntityGraph(name = "post-with-comment-users", graph = "subject, user, comments(user)")
@Entity
public class Post {
    // ...
}

Furthermore, we can use the @NamedEntityGraph annotation to define multiple entity graphs on the same entity:

@NamedEntityGraph(name = "post-basic", graph = "subject, user, comments")
@NamedEntityGraph(name = "post-with-comment-users", graph = "subject, user, comments(user)")
@NamedEntityGraph(name = "post-with-typed-users", graph = "subject, user(name),
    user(Author: bio), user(Moderator: department)")
@Entity
public class Post {
    // ...
}

Based on the definitions above, we can now use post-basic to fetch only comments without their users, while a detailed page can use post-with-comment-users to load the full comment tree.

Of course, we can also place the annotation at the package level using the package-info.java file. However, the graph string must be prefixed with the entity name:

@org.hibernate.annotations.NamedEntityGraph(name = "package-post-with-comment-users", graph = "Post: subject, user, comments(user)")
package com.baeldung.hibernate.entitygraph.model;

This way, Hibernate can infer which entity the graph belongs to.

4.3. Subtype-Specific Subgraphs

The text syntax also supports targeting specific subtypes in an inheritance hierarchy. A Post references a User, and Hibernate determines the concrete type at runtime.

To that end, we can target each subtype by prefixing the attributes with the subtype name:

@NamedEntityGraph(name = "post-with-typed-user", graph = "subject, user(name), user(Author: bio), user(Moderator: department)")
@Entity
public class Post {
    // ...
}

This graph definition tells Hibernate that the User name is to be fetched in all cases, and if it’s an Author, fetch its bio, or if it’s a Moderator, then fetch the department.

4.4. Map Key Subgraphs

If the attribute is a Map and the map’s key is itself a managed entity, we can define a subgraph for the key by appending .key to the attribute name.

For example, if the Post entity had a Map attribute called commentsByUser, we can fetch the user name along with the map entry:

@org.hibernate.annotations.NamedEntityGraph(graph = "commentsByUser.key(name)")

Without the .key, the subgraph would apply to the map value type, which is Comment in this case.

5. Using the GraphParser

Hibernate also exposes GraphParser, which enables graph creation at runtime. The parse(), method accepts an entity class, the graph string, and EntityManager:

final EntityGraph graph = GraphParser
    .parse(Post.class, "subject, user, comments(user)", entityManager);

We can also enrich an existing graph or subgraph at runtime using the parseInto() method:

EntityGraph graph = GraphParser.createEntityGraph(Post.class);
GraphParser.parseInto(graph, "subject, user", entityManger);
GraphParser.parseInto(graph, "comments(user)", entityManger);

Thus, we ensure proper typing.

6. Merging Graphs

Different aspects of the graph may be defined at multiple parts of an application. Hibernate enables us to combine multiple entity graphs into a single graph, which is the union of all the graphs using the merge() method:

EntityGraph mergedGraph = EntityGraphs.merge(entityManager, Post.class,
    entityManager.getEntityGraph("post-basic"),
    entityManager.getEntityGraph("post-with-comment-users"));

The merged graph fetches everything from both graphs into a single query; we could’ve used the graph string approach as well with the same effect.

7. Using the Graphs

Once an entity graph has been defined, either at runtime or via an annotation, it needs to be applied to an actual query. There are two possible approaches: one is via the plain JPA EntityManager, as we saw in the JPA tutorial, and the other option is to use Spring Data JPA.

7.1. Using EntityManager

The standard JPA approach uses hints, where we pass a Map, with either jakarta.persistence.fetchgraph or jakarta.persistence.loadgraph as the key and the EntityGraph object as the value:

EntityGraph graph = entityManager.getEntityGraph("post-with-comment-users");
        
Map hints = Map.of("jakarta.persistence.fetchgraph", graph);
        
Post post = entityManager.find(Post.class, 1L, hints);

The hint key determines the behaviour; using fetchgraph or loadgraph determines what is loaded.

Importantly, we can apply the same hint either to EntityManager.find() or to a JPQL query.

7.2. Using Spring Data JPA

Critically, we can skip the hints while using Spring Data JPA. The @EntityGraph annotation handles the wiring internally once we reference the graph by name on a repository method. In addition, we can set the type explicitly:

public interface PostRepository extends JpaRepository {
    @EntityGraph(value = "post-basic", type = EntityGraph.EntityGraphType.LOAD)
    List findAll(String subject);
    @EntityGraph(value = "post-with-comment-users")
    Post findBySubject(String subject);
}

Otherwise, Hibernate treats the graphs as fetchgraph by default.

8. Testing

Let’s explore a few scenarios to verify how these entity graphs work in practice.

8.1. Using a Named Graph

Let’s start with a simple named entity graph post-with-comment-users and apply it using fetchgraph:

@Test
void whenFindWithFetchGraph_thenAssociationsAreLoaded() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityGraph graph = (EntityGraph) entityManager.getEntityGraph("post-with-comment-users");
    Post post = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", graph)
        .getSingleResult();
    entityManager.close();
    assertNotNull(post);
    assertEquals("First Post", post.getSubject());
    assertTrue(Hibernate.isInitialized(post.getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments()));
    assertEquals(2, post.getComments().size());
    assertTrue(Hibernate.isInitialized(post.getComments().get(0).getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments().get(1).getUser()));
}

Here, we verify that the named entity graph fetches Post and all its associations, including the commenting User.

8.2. Using EntityManager.find()

On the other hand, we can also apply the same named graph using EntityManager.find():

@Test
void whenFindingByIdWithEntityManagerHints_thenAssociationsAreLoaded() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    Long postId = entityManager.createQuery("Select p.id from Post p where p.subject = :subject", Long.class)
        .setParameter("subject", "First Post")
        .getSingleResult();
    EntityGraph graph = (EntityGraph) entityManager.getEntityGraph("post-with-comment-users");
    Post post = entityManager.find(Post.class, postId, Map.of("jakarta.persistence.fetchgraph", graph));
    entityManager.close();
    assertNotNull(post);
    assertEquals("First Post", post.getSubject());
    assertTrue(Hibernate.isInitialized(post.getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments()));
    assertEquals(2, post.getComments().size());
    assertTrue(Hibernate.isInitialized(post.getComments().get(0).getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments().get(1).getUser()));
}

This shows that the same graph can be applied using JPA hints outside a JPQL query as well.

8.3. Comparing Multiple Graphs

Let’s take a look at how multiple named entity graphs defined on the entity work.

In this case, we use the post-basic named entity graph and compare it with the post-with-comments-user one:

@Test
void whenUsingPostBasicGraph_thenCommentUsersRemainLazy() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityGraph graph = (EntityGraph) entityManager.getEntityGraph("post-basic");
    Post post = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", graph)
        .getSingleResult();
    entityManager.close();
    assertNotNull(post);
    assertEquals("First Post", post.getSubject());
    assertTrue(Hibernate.isInitialized(post.getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments()));
    assertFalse(Hibernate.isInitialized(post.getComments().get(0).getUser()));
}

As we can see, the Post and all associations are loaded similarly to the previous example; however, the User for the Comments is lazy.

8.4. Subtype-Specific Subgraphs

Next, we verify how to fetch the subtype-specific subgraphs.

Specifically, we defined the post-with-typed-user graph:

@Test
void whenUsingTypedUserGraph_thenSubtypeAttributesAreLoaded() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityGraph graph = (EntityGraph) entityManager.getEntityGraph("post-with-typed-user");
    Post authorPost = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", graph)
        .getSingleResult();
    Post moderatorPost = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "Second Post")
        .setHint("jakarta.persistence.fetchgraph", graph)
        .getSingleResult();
    entityManager.close();
    assertNotNull(authorPost);
    assertTrue(Hibernate.isInitialized(authorPost.getUser()));
    assertEquals("Author 1", authorPost.getUser().getName());
    assertInstanceOf(Author.class, authorPost.getUser());
    assertTrue(Hibernate.isPropertyInitialized(authorPost.getUser(), "bio"));
    assertEquals("A Baeldung Author", ((Author) authorPost.getUser()).getBio());
    assertNotNull(moderatorPost);
    assertTrue(Hibernate.isInitialized(moderatorPost.getUser()));
    assertEquals("Moderator 1", moderatorPost.getUser().getName());
    assertInstanceOf(Moderator.class, moderatorPost.getUser());
    assertTrue(Hibernate.isPropertyInitialized(moderatorPost.getUser(), "department"));
    assertEquals("A Baeldung Moderator", ((Moderator) moderatorPost.getUser()).getDepartment());
}

This code should fetch the name for all User types and the bio if it’s an Author or the department if it’s a Moderator instance.

8.5. Parsing Graphs at Runtime

Hibernate also enables us to build graphs at runtime.

When using the parse() method, we can create a new graph:

@Test
void whenParsingGraphsAtRuntime_thenAssociationsAreLoaded() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityGraph parsedGraph = GraphParser.parse(Post.class, "subject, user, comments(user)", entityManager);
    EntityGraph parsedIntoGraph = entityManager.createEntityGraph(Post.class);
    GraphParser.parseInto(parsedIntoGraph, "subject, user", entityManager);
    GraphParser.parseInto(parsedIntoGraph, "comments(user)", entityManager);
    Post parsedPost = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", parsedGraph)
        .getSingleResult();
    Post parsedIntoPost = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", parsedIntoGraph)
        .getSingleResult();
    entityManager.close();
    assertNotNull(parsedPost);
    assertEquals("First Post", parsedPost.getSubject());
    assertTrue(Hibernate.isInitialized(parsedPost.getUser()));
    assertTrue(Hibernate.isInitialized(parsedPost.getComments()));
    assertEquals(2, parsedPost.getComments().size());
    assertTrue(Hibernate.isInitialized(parsedPost.getComments().get(0).getUser()));
    assertTrue(Hibernate.isInitialized(parsedPost.getComments().get(1).getUser()));
    assertNotNull(parsedIntoPost);
    assertEquals("First Post", parsedIntoPost.getSubject());
    assertTrue(Hibernate.isInitialized(parsedIntoPost.getUser()));
    assertTrue(Hibernate.isInitialized(parsedIntoPost.getComments()));
    assertEquals(2, parsedIntoPost.getComments().size());
    assertTrue(Hibernate.isInitialized(parsedIntoPost.getComments().get(0).getUser()));
    assertTrue(Hibernate.isInitialized(parsedIntoPost.getComments().get(1).getUser()));
}

Notably, we can enrich an existing graph with the parseInto() method.

8.6. Merging Graphs

Finally, we can merge multiple graphs into a single graph:

@Test
void whenMergingGraphs_thenUnionOfAttributesIsLoaded() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityGraph basicGraph = (EntityGraph) entityManager.getEntityGraph("post-basic");
    EntityGraph postWithCommentUsersGraph = (EntityGraph) entityManager.getEntityGraph("post-with-comment-users");
    EntityGraph mergedGraph = EntityGraphs.merge(entityManager, Post.class,
        basicGraph,
        postWithCommentUsersGraph);
    Post post = entityManager.createQuery("Select p from Post p where p.subject = :subject", Post.class)
        .setParameter("subject", "First Post")
        .setHint("jakarta.persistence.fetchgraph", mergedGraph)
        .getSingleResult();
    entityManager.close();
    assertNotNull(post);
    assertEquals("First Post", post.getSubject());
    assertTrue(Hibernate.isInitialized(post.getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments()));
    assertEquals(2, post.getComments().size());
    assertTrue(Hibernate.isInitialized(post.getComments().get(0).getUser()));
    assertTrue(Hibernate.isInitialized(post.getComments().get(1).getUser()));
}

Thus, we get the union of all the merged graphs.

9. Conclusion

In this article, we explored the @NamedEntityGraph annotation of Hibernate as well as the text-based graph language behind it.

First, we started with simple attribute lists, exploring nested subgraphs and subtype-specific subgraphs. Next, we looked into the GraphParser, which enables parsing graphs at runtime, and the EntityGraph merging of multiple graphs. Finally, we compared how simple, clear, and concise the Hibernate version is as compared to the JPA version.

As always, the code is available over on GitHub.

The post A Guide to @NamedEntityGraph in Hibernate first appeared on Baeldung.

Java Weekly, Issue 643

baeldung — Thu, 23 Apr 2026 19:26:11 +0000

1. Spring and Java

>> Distributed Cache Invalidation Patterns [foojay.io]

A pragmatic tour through distributed cache invalidation, with concrete Spring Boot + Redis code for each pattern. Good brushup.

Also worth reading:

>> Eliminating Flaky Tests to End World Hunger [foojay.io]
>> BoxLang AI Deep Dive — Part 3 of 7: Multi-Agent Orchestration [foojay.io]
>> Crossing the River Styx: Spring Boot 3.5 and the Zombie Dependency Problem [foojay.io]
>> Which Java Runtime Should You Use in Production? Comparing OpenJDK Distributions [foojay.io]
>> Redesigning Banking PDF Table Extraction: A Layered Approach with Java [infoq.com]
>> Google ADK for Java 1.0 Introduces New App and Plugin Architecture [infoq.com]
>> Building a Personalized Content Delivery System [foojay.io]
>> How the JVM Optimizes Generic Code [inside.java]
>> You Must Avoid Final Field Mutation – Inside Java Newscast #110 [nipafx.dev]
>> Kotlin Professional Certificate by JetBrains – Now on LinkedIn Learning [jetbrains.com]
>> Introducing Koog Integration for Spring AI [jetbrains.com]

Webinars and presentations:

>> Episode 56 “Ask the Architects at JavaOne” [AtA] [inside.java]
>> Episode 55 “You Must Avoid Final Field Mutation” [IJN] [inside.java]
>> A Bootiful Podcast: Dr. Venkat Subramaniam and James Ward [spring.io]
>> Spring Office Hours Podcast: S5E13 – Community Potluck [spring.io]
>> A Bootiful Podcast: the legendary Craig Walls [spring.io]

Time to upgrade:

>> Azul Zulu April 2026 Quarterly Update Released [foojay.io]
>> Jakarta Persistence 4.0 Milestone 2 [in.relation.to]
>> Quality Outreach Heads-up – JDK 27: Obsolete Translation Resources Removed [inside.java]
>> IntelliJ IDEA 2026.1.1 Is Out! [jetbrains.com]
>> Quarkus 3.34.6 and 3.34.5 – Maintenance releases [quarkus.io]
>> Spring Boot 3.5.14, 4.0.6, and 4.1.0-RC1 available now [spring.io]
>> Spring for Apache Pulsar 1.2.17 and 2.0.5 are now available [spring.io]
>> Spring for Apache Kafka 4.1.0-RC1, 4.0.5, and 3.3.15 Available [spring.io]
>> Spring Security 2026.04 Releases – Contains CVE Fixes [spring.io]
>> Spring Authorization Server 1.5.7 Available Now [spring.io]
>> Spring Data 2025.1.5 and 2025.0.11 released [spring.io]
>> Spring Data 2026.0.0-RC1 enters release candidate phase [spring.io]
>> Spring Framework 6.2.18 and 7.0.7 Available Now [spring.io]
>> Vert.x 5.0.11 [github.com/eclipse-vertx]
>> Apache Camel 4.14.6, 4.14.7, 4.18.2, and 4.20.0 [github.com/apache]
>> Helidon 3.2.17 [github.com/helidon-io]
>> Payara Platform 7.2026.4 [github.com/payara]

2. Technical & Musings

>> Making illegal state unrepresentable [frankel.ch]

A solid take on the classic make illegal states unrepresentable principle, walking through the idea across several languages. Types are still our first line of defense against bad data.

Also worth reading:

>> Yoda Principle for better integrations [event-driven.io]
>> Playing Well With Others: An Example [jbrains.ca]
>> The invisible engineering behind Lambda’s network [allthingsdistributed.com]
>> OpenTelemetry glossary: 30 terms you should know [nurkiewicz.com]
>> The Human Infrastructure: How Netflix Built the Operations Layer Behind Live at Scale [netflixtechblog.com]
>> Predicting Risk in Content Launches [netflixtechblog.com]

3. Pick of the Week

>> How The Heck Does Shazam Work? [perthirtysix.com]

The post Java Weekly, Issue 643 first appeared on Baeldung.

Importing p7b File to Java Keystore Using Keytool in Java

Vishal Shanbhag — Wed, 22 Apr 2026 05:02:48 +0000

1. Introduction

When working with production applications in Java, we often find ourselves configuring HTTPS, enabling secure outbound communication, or managing trust stores. Keytool is the standard tool for working with the required keys and certificates and thus managing Java keystores.

In this tutorial, we’ll focus on a specific task: importing a p7b certificate file into a Java keystore using keytool.

2. Understanding the P7B (PKCS#7) Format

Before we dive into the steps to import a P7B file, it’s worth reviewing and understanding the PKCS#7 format.

In cryptography, PKCS#7 is a standard syntax for storing cryptographically signed or encrypted data.

One common use for this format is to store SSL certificates. Often, certificate bundles are stored and shared as a .p7b file format.

2.1. Certificate Bundle

When creating self signed certificates for development use, it’s usually sufficient to have a private key and a self-signed certificate containing the public key. However, when working with production applications that are expected to be available over the internet, we typically need our certificates to be validated by a known Certificate Authority (CA).

Browsers validate a site by validating the site’s certificate. Each site presents its own certificate along with information to a chain of intermediate certificates, eventually leading to the root certificate of a CA. Since the browsers trust the CA, any site presenting a validated certificate with a clear chain of certificates leading to a root CA certificate is considered valid.

Once a certificate is validated by a CA, they typically provide a certificate chain consisting of its own root certificate and zero or more intermediate certificates. This certificate chain is provided as a bundle of certificates, sometimes as a .p7b file.

2.2. The P7B Format

A P7B file is a PKCS#7 container that can store one or more certificates. It may be encoded either in the binary DER format or in the Base64 PEM format.

When working with Java servers (such as Tomcat), we need to ensure that all the certificates in the bundle are imported into our keystore to prove the validity of our certificate.

Browsers on all modern devices recognise certificates validated by a CA. During the process of certificate validation, a CA will typically share the signed public certificate for our site along with a certificate chain, aka certificate bundle.

Sometimes, the certificate bundle comes as a file with a .p7b extension. We note that depending on the encoding, the contents may not be easily readable in a plain text editor. Therefore, we need a few tools to work with these certificates and import them into our keystore.

3. Preparing a P7B File

Now that we’ve understood the P7B format, let’s dive into the process.

Before we can import a certificate bundle, we need a file containing the certificate bundle. Since we don’t have a .p7b provided by a CA, we’ll use the public certificate from Baeldung.com.

First, we’ll download the chain and convert it into the P7B file format.

3.1. Downloading the Certificate Bundle

Most modern browsers allow exporting of certificates to PKCS#7 format encoded files. However, we’ll do a full command-line interface version using the openssl command on a Linux terminal:

$ openssl s_client -connect www.baeldung.com:443 -showcerts


This command prints out several certificates along with some other information about each certificate. Each certificate can be identified easily because of the beginning and ending markers:
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
We can now copy each of those certificates (including the markers) and store them as a separate .pem file. So now we have three files site.pem, intermediate.pem and root.pem.
Now let’s use them to create a .p7b bundle:
$ openssl crl2pkcs7 -nocrl -certfile site.pem -certfile intermediate.pem \
-certfile root.pem -out site-chain.p7b
Finally, we can verify that all certificates of interest are present in the bundle:
$ openssl pkcs7 -print_certs -in site-chain.p7b -noout
We see three certificates printed clearly as expected.
3.2. The Problem Importing P7B File

Now that we have a valid certificate bundle in the .p7b file format, let’s check it with keytool:
$ keytool -printcert -file site-chain.p7b
This command prints information about the three certificates clearly.
Let’s attempt to import this as-is:
$ keytool -importcert -file site-chain.p7b -keystore test-keystore.jks -alias site
The output presents an error:
keytool error: java.lang.Exception: Input not an X.509 certificate
The certificate import fails because the keytool -importcert expects the input file to contain exactly one X.509 PEM or DER encoded certificate.
4. Importing the P7B File

We observe that the direct import of a certificate bundle using keytool can be problematic. The solution is to break down the bundle into its individual certificates and then import those certificates one by one.
4.1. Converting to PEM Encoding

To break the bundle into individual PEM files, first, we’ll convert the bundle from the PKCS #7 to a PEM encoded bundle:
$ openssl pkcs7 -print_certs -in site-chain.p7b -out site-chain.pem
This produces a PEM file containing one or more X.509 certificates:












-----BEGIN CERTIFICATE-----
.......
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
.......
-----END CERTIFICATE-----












We’re now ready to use keytool to import the certificates.
4.2. Importing the PEM Bundle

Now that the file is in a format compatible with the keytool import option, we can perform the input:
$ keytool -importcert -file site-chain.pem -keystore test-keystore.jks -alias site
This command requires us to set a keystore password and asks us if we trust the certificate. Then the output shows success:
Trust this certificate? [no]:  yes
Certificate was added to keystore
This imports the site’s certificate under the alias site.
If we need the intermediate and root certificates as well in the same keystore, then we need to import them individually. From site-chain.pem we can copy each of those certificates (including the begin and end markers) and store them as a separate .pem file. So now we have two more files, intermediate.pem and root.pem.
We can use the same command with different input files and aliases to import the root and intermediate certificates as well:
$ keytool -importcert -file root.pem -keystore test-keystore.jks -alias root
$ keytool -importcert -file intermediate.pem -keystore test-keystore.jks -alias intermediate
4.3. Verifying the Import

Now we have all certificates imported, let’s verify them:
$ keytool -list -v -keystore test-keystore.jks
This command requests the previously set password and then shows us detailed information about all the imported certificates. At the beginning of the output, we see:
Keystore type: PKCS12
Keystore provider: SUN
Your keystore contains 3 entries

That’s it. Our keystore is now ready to use.
5. Conclusion

In this article, we explored how keytool works with certificate bundles in the PKCS#7 (.p7b) format. While these files can contain complete certificate chains, they’re not always directly supported for import.
We learnt that keytool expects X.509 certificates in DER or PEM format, not container formats like PKCS#7. Converting the .p7b bundle into individual certificates ensures a successful and predictable import process.
The post Importing p7b File to Java Keystore Using Keytool in Java first appeared on Baeldung.

Baeldung

Java Weekly, Issue 644

1. Spring and Java

Also worth reading:

Webinars and presentations:

Time to upgrade:

2. Technical & Musings

Also worth reading:

3. Pick of the Week

IntelliJ Series

IDE Setup and Configuration

Project and Build Management

Coding and Editing

Debugging

Code Analysis and Navigation

Jakarta EE Series

Jakarta EE Platform and Core Concepts

Servlets

JSP and JSF

Web Services: JAX-RS and JAX-WS

Bean Validation

CDI and EJB

Java Maps Series

Map Implementations

Creating and Initializing Maps

Reading, Updating, and Removing Entries

Iterating and Streaming Maps

Sorting, Searching, and Comparing Maps

Converting Maps

Java List Series

List Types and Fundamentals

Creating and Initializing Lists

Adding, Removing, and Modifying Elements

Iterating and Sorting Lists

Searching and Filtering Lists

Converting Lists

Store Java Objects in HttpSession

1. Introduction

2. What is HttpSession?

3. Storing a Java Object in HttpSession

4. Retrieving a Java Object from HttpSession

5. Removing an Object from HttpSession

6. Conclusion

Algorithms in Java Series

Sorting and Searching

Graph and Tree Algorithms

Array and String Algorithms

Mathematical Algorithms

Optimization and AI Algorithms

Concurrency and Systems Algorithms

Spring AI Series

Getting Started with Spring AI

AI Models and Providers

RAG and Vector Stores

Advisors and AI Agents

Model Context Protocol (MCP)

Multimodal and Advanced Capabilities

AI in Java Series

Getting Started with AI in Java

Building with Spring AI

RAG and Vector Search

Model Context Protocol (MCP)

AI Agents

Deep Learning and ML Libraries

A Guide to @NamedEntityGraph in Hibernate

1. Overview

2. Setup

2.1. Hibernate ORM

2.2. Data Model

3. Text-Based Graph Language

4. Understanding @NamedEntityGraph

4.1. Simple Graph

4.2. Defining Multiple Graphs

4.3. Subtype-Specific Subgraphs

4.4. Map Key Subgraphs

5. Using the GraphParser

6. Merging Graphs

7. Using the Graphs

7.1. Using EntityManager

7.2. Using Spring Data JPA