Spring Boot – “Error creating bean with name ‘entityManagerFactory'” – Start

Direct Answer

• Key Points:
  To fix the “Error creating bean with name ‘entityManagerFactory'” in Spring Boot, change the @Id annotation import in your Degree entity from org.springframework.data.annotation.Id to javax.persistence.Id. This ensures JPA recognizes the primary key, resolving the “No identifier specified for entity” error. Also, ensure your package names and variable names are correctly formatted without spaces.
• What’s the Problem?
  The error occurs because Spring Boot’s JPA (using Hibernate) expects the @Id annotation from javax.persistence.Id for entity primary keys, but your code uses org.springframework.data.annotation.Id, which is for Spring Data and not recognized by JPA. This causes the entity manager factory to fail during startup.
• How to Fix It
  Open your Degree entity class (in pack.datas.entities), and update the import statement:
• Change import org.springframework.data.annotation.Id; to import javax.persistence.Id;.
• Keep the @Id annotation on your id field as is.
• Restart your application, and the error should be resolved.
• Surprising Detail: Package and Naming Issues
  Your code snippets show spaces in package names (e.g., “pack datas”) and variable names (e.g., “degree Id”), which are invalid in Java. Ensure package names use dots (e.g., pack.datas.entities) and variable names use camelCase (e.g., degreeId), as these formatting errors might cause additional issues.

Survey Note: Detailed Analysis and Resolution

This section provides a comprehensive analysis of the “Error creating bean with name ‘entityManagerFactory'” issue in Spring Boot, focusing on the “No identifier specified for entity” error for the Degree entity. We’ll explore the root cause, step-by-step solutions, and additional considerations to ensure a robust application setup.

Understanding the Error

The error message indicates a failure in initializing the JPA entity manager factory. This is critical for Spring Boot applications using Spring Data JPA, as it manages database entity mappings.

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in class path resource [org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfiguration.class]: Invocation of init method failed; nested exception is org.hibernate.AnnotationException: No identifier specified for entity: pack.datas.entities.Degree

The nested exception, org.hibernate.AnnotationException: No identifier specified for entity: pack.datas.entities.Degree, suggests that Hibernate (the JPA provider) cannot find a primary key (identifier) for the Degree entity. In JPA, every entity must have a field annotated with @Id to define its unique identifier, which is essential for database operations.

Analyzing the Code

Let’s break down the provided code to identify the issue:

• Main Application Class:
  The entry point is in package pack;, with annotations like @SpringBootApplication(exclude={DataSourceAutoConfiguration.class}), @RestController, and @EntityScan. The exclusion of DataSourceAutoConfiguration implies manual datasource configuration, which is handled in the DatasFactory class.
• DatasFactory Class:
  Located in package pack.datas;, this class (@Component, @Configuration, @EnableJpaRepositories) manually configures a datasource using @Bean and @ConfigurationProperties(prefix="spring.datasource"). This setup is valid but doesn’t directly relate to the entity issue.
• Degree Entity Class:
  In package pack.datas.entities;, the Degree class is annotated with @Entity and @Table(name = "degree"). The relevant field is:

  @Id
  @GeneratedValue
  @Column(name = "pk_id")
  private Integer id;

However, the import for @Id is from org.springframework.data.annotation.Id, which is the root cause. This annotation is part of Spring Data, typically used for non-relational databases like MongoDB, and is not recognized by Hibernate for JPA entities.

Root Cause: Incorrect @Id Annotation

The error arises because org.springframework.data.annotation.Id is not the standard JPA annotation. JPA expects @Id from javax.persistence.Id, which is part of the Java Persistence API and compatible with Hibernate. Using the wrong annotation leads Hibernate to fail in identifying the primary key, resulting in the “No identifier specified for entity” error.

This issue is common among developers new to Spring Boot, especially when mixing Spring Data and JPA annotations. Research from community forums, such as Stack Overflow: Spring Boot JPA Hibernate: No identifier specified for entity error even when @Id is present in the entity class, confirms that switching the import resolves the issue.

Step-by-Step Solution

To fix the error, follow these steps:

1. Locate the Degree Entity: Open the Degree class in pack.datas.entities.
2. Update the @Id Import: Change the import statement from:

• import org.springframework.data.annotation.Id; to
• import javax.persistence.Id;.

1. Verify Annotations: Ensure the @Id, @GeneratedValue, and @Column annotations remain on the id field. No other changes are needed for this fix.
2. Restart the Application: Run the Spring Boot application again. The error should be resolved, and the entity manager factory will initialize correctly.

Additional Observations and Best Practices

During analysis, several formatting issues were noted in the provided code, likely due to copy-paste errors. These include:

• Package Names with Spaces: The user’s code shows “pack datas” and “pack datas entities,” which are invalid. In Java, package names must use dots (e.g., pack.datas.entities) and cannot contain spaces.
• Variable Names with Spaces: Fields like “degree Id” and “degree En” appear with spaces, which are invalid. Java variable names should use camelCase (e.g., degreeId, degreeEn).
• Configuration Files: The application.yml shows spaces in keys (e.g., “data source” instead of datasource), which should be corrected to standard YAML format. For example:
• Correct: spring.datasource.url: jdbc:postgresql://localhost:5432/recruitments_db.
• Ensure database names (e.g., “recruitments db”) use underscores (recruitments_db) if spaces are intended.

These formatting issues, while not directly causing the entity error, could lead to compilation or runtime issues and should be addressed for a clean codebase.

Version Considerations

The user’s pom.xml uses Spring Boot version 1.4.2.RELEASE, which is quite old (released in 2016). While this version supports the fix, upgrading to a newer version (e.g., 2.3.3.RELEASE or later) is recommended for better compatibility and security. For example, Code2care: [fix] Spring Boot Data JPA – No identifier specified for entity suggests that newer versions might handle annotation conflicts better. To update, modify the pom.xml parent version:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
    <relativePath/>
</parent>

Entity Scanning and Configuration

The main class uses @EntityScan without arguments, which defaults to scanning the package of the @SpringBootApplication class (pack) and its subpackages. Given the entity is in pack.datas.entities, it should be scanned automatically. However, for clarity, you can explicitly specify the package:

@SpringBootApplication
@EntityScan("pack.datas.entities")
public class CandidatesRecruitmentApplication {
    // ...
}

This ensures no scanning issues, especially if package structures are complex.

Comparative Analysis: @Id Annotations

To illustrate the difference, here’s a table comparing the two @Id annotations:

This table highlights why using javax.persistence.Id is essential for JPA entities in Spring Boot.

Conclusion

The “Error creating bean with name ‘entityManagerFactory'” due to “No identifier specified for entity” is resolved by switching the @Id annotation import from org.springframework.data.annotation.Id to javax.persistence.Id in the Degree entity. This ensures Hibernate recognizes the primary key, allowing the entity manager factory to initialize. Additionally, address formatting issues in package and variable names, and consider upgrading Spring Boot for long-term stability. With these changes, your Spring Boot application should run smoothly.

Key Citations

• Stack Overflow: Spring Boot JPA Hibernate: No identifier specified for entity error even when @Id is present in the entity class
• Code2care: [fix] Spring Boot Data JPA – No identifier specified for entity