How to Define a Bean Named 'EntityManagerFactory' in Your Configuration - A Step-by-Step Guide

In this guide, we will provide a step-by-step solution to a common issue faced by developers when working with Spring Boot and JPA: defining a bean named 'EntityManagerFactory' in the configuration. Let's get started!

Table of Contents


When working with Spring Boot and JPA, it's common to encounter issues related to configuring the EntityManagerFactory bean. This usually happens when Spring Boot is unable to auto-configure the EntityManagerFactory due to misconfigurations or missing dependencies.

In this guide, we will walk you through the process of defining the EntityManagerFactory bean in your Spring Boot configuration to resolve this issue.


Before proceeding with this guide, make sure you have the following:

  • JDK 8 or later installed on your machine
  • A basic understanding of Spring Boot and JPA
  • A Spring Boot project with JPA and a database configured

Step 1: Verify the Spring Boot version

First, ensure that you are using the correct version of Spring Boot. This guide assumes that you are using Spring Boot 2.x. You can check your Spring Boot version in your project's pom.xml or build.gradle file.

For example, in pom.xml, look for the following:


Step 2: Configure the EntityManagerFactory bean

In your project, create a configuration class (@Configuration) that defines the EntityManagerFactory bean. This class should extend org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration and override the entityManagerFactory method.

Here's an example:

import org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;

import javax.sql.DataSource;

public class JpaConfiguration extends JpaBaseConfiguration {

    protected JpaConfiguration(DataSource dataSource, JpaProperties properties, ObjectProvider<JtaTransactionManagerCustomizer> jtaTransactionManagerCustomizer) {
        super(dataSource, properties, jtaTransactionManagerCustomizer);

    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource,
            JpaVendorAdapter jpaVendorAdapter) {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        return factory;

Don't forget to replace com.example.your_package with the actual package where your entities are located.

Step 3: Define the DataSource bean

Next, define the DataSource bean in your configuration class. You can use Spring Boot's DataSourceBuilder to create the bean. Make sure to provide the required database connection properties.

Here's an example:

import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

public class DataSourceConfiguration {

    public DataSource dataSource() {
        return DataSourceBuilder.create()

Don't forget to replace the placeholders with your actual database connection details.

Step 4: Verify the file

Ensure that your file contains the correct JPA properties. Here's an example:

Step 5: Run the application

Now that you've defined the EntityManagerFactory and DataSource beans and configured the necessary properties, you should be able to run your Spring Boot application without any issues.


Q1: How can I customize the EntityManagerFactory configuration?

To customize the EntityManagerFactory configuration, you can modify the entityManagerFactory method in your JpaConfiguration class. You can set various properties on the LocalContainerEntityManagerFactoryBean instance, such as the JPA properties, the JPA vendor adapter, and the packages to scan for entities.

Q2: Why do I need to define the DataSource bean?

The DataSource bean is required to provide a connection to your database. When you define the DataSource bean, you can configure the connection properties, such as the database URL, username, password, and driver class name.

Q3: Can I use other databases with this guide?

Yes, this guide can be adapted for other databases. You will need to change the database-specific properties, such as the driver class name, the dialect, and the connection URL. You may also need to add the appropriate database driver dependency to your project.

Q4: What if I am using Spring Boot 1.x?

If you are using Spring Boot 1.x, you may need to make some changes to the configuration to ensure compatibility. For example, the JpaBaseConfiguration class used in this guide is not available in Spring Boot 1.x. Instead, you can extend the org.springframework.boot.orm.jpa.EntityScan annotation to define the EntityManagerFactory bean.

Q5: What is the role of the JpaRepository interface in this configuration?

The JpaRepository interface is not directly related to the configuration of the EntityManagerFactory bean. However, JpaRepository interfaces are used to create repository instances for your entities. These repositories use the EntityManagerFactory to interact with the database.

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.