Spring boot - Not a managed type

I use Spring boot+JPA and having a problem while starting the service.

Caused by: java.lang.IllegalArgumentException: Not an managed type: class com.nervytech.dialer.domain.PhoneSettings
	at org.hibernate.jpa.internal.metamodel.MetamodelImpl.managedType(MetamodelImpl.java:219)
	at org.springframework.data.jpa.repository.support.JpaMetamodelEntityInformation.<init>(JpaMetamodelEntityInformation.java:68)
	at org.springframework.data.jpa.repository.support.JpaEntityInformationSupport.getMetadata(JpaEntityInformationSupport.java:65)
	at org.springframework.data.jpa.repository.support.JpaRepositoryFactory.getEntityInformation(JpaRepositoryFactory.java:145)
	at org.springframework.data.jpa.repository.support.JpaRepositoryFactory.getTargetRepository(JpaRepositoryFactory.java:89)
	at org.springframework.data.jpa.repository.support.JpaRepositoryFactory.getTargetRepository(JpaRepositoryFactory.java:69)
	at org.springframework.data.repository.core.support.RepositoryFactorySupport.getRepository(RepositoryFactorySupport.java:177)
	at org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport.initAndReturn(RepositoryFactoryBeanSupport.java:239)
	at org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport.afterPropertiesSet(RepositoryFactoryBeanSupport.java:225)
	at org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean.afterPropertiesSet(JpaRepositoryFactoryBean.java:92)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1625)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1562)

Here is the Application.java file,

@Configuration
@ComponentScan
@EnableAutoConfiguration(exclude = { DataSourceAutoConfiguration.class })
@SpringBootApplication
public class DialerApplication {

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

I use UCp for connection pooling and the DataSource configuration is below,

@Configuration
@ComponentScan
@EnableTransactionManagement
@EnableAutoConfiguration
@EnableJpaRepositories(entityManagerFactoryRef = "dialerEntityManagerFactory", transactionManagerRef = "dialerTransactionManager", basePackages = { "com.nervy.dialer.spring.jpa.repository" })
public class ApplicationDataSource {

	/** The Constant LOGGER. */
	private static final Logger LOGGER = LoggerFactory
			.getLogger(ApplicationDataSource.class);

	/** The Constant TEST_SQL. */
	private static final String TEST_SQL = "select 1 from dual";

	/** The pooled data source. */
	private PoolDataSource pooledDataSource;

UserDetailsService Implementation,

@Service("userDetailsService")
@SessionAttributes("user")
public class UserDetailsServiceImpl implements UserDetailsService {
    	   
	@Autowired
	private UserService userService;

Service layer implementation,

@Service
public class PhoneSettingsServiceImpl implements PhoneSettingsService {

}

The repository class,

@Repository
public interface PhoneSettingsRepository extends JpaRepository<PhoneSettings, Long> {

}

Entity class,

@Entity
@Table(name = "phone_settings", catalog = "dialer")
public class PhoneSettings implements java.io.Serializable {

WebSecurityConfig class,

@Configuration
@EnableWebMvcSecurity
@ComponentScan
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
	
	@Autowired
	private UserDetailsServiceImpl userDetailsService;

    /**
     * Instantiates a new web security config.
     */
    public WebSecurityConfig() {

        super();
    }

    /**
     * {@inheritDoc}
     * @see org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#configure(org.springframework.security.config.annotation.web.builders.HttpSecurity)
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
    	
        http.authorizeRequests()
            .antMatchers("/login", "/logoffUser", "/sessionExpired", "/error", "/unauth", "/redirect", "*support*").permitAll()
            .anyRequest().authenticated().and().rememberMe().and().httpBasic()
            .and()
            .csrf()
            .disable().logout().deleteCookies("JSESSIONID").logoutSuccessUrl("/logoff").invalidateHttpSession(true);
    }
    
    
    @Autowired
	public void configAuthentication(AuthenticationManagerBuilder auth) throws Exception {
 
      auth.userDetailsService(userDetailsService).passwordEncoder(new BCryptPasswordEncoder());
	}

}

The packages are as follows,

1. Application class is in - com.nervy.dialer
2. Datasource class is in - com.nervy.dialer.common
3. Entity classes are in - com.nervy.dialer.domain
4. Service classes are in - com.nervy.dialer.domain.service.impl
5. Controllers are in - com.nervy.dialer.spring.controller
6. Repository classes are in - com.nervy.dialer.spring.jpa.repository
7. WebSecurityConfig is in - com.nervy.dialer.spring.security

Thanks

Configure the location of entities using @EntityScan in Spring Boot entry point class.

Update on Sept 2016: For Spring Boot 1.4+:
use org.springframework.boot.autoconfigure.domain.EntityScan
instead of org.springframework.boot.orm.jpa.EntityScan, as ...boot.orm.jpa.EntityScan is deprecated as of Spring Boot 1.4

Try adding All the following, In my application it is working fine with tomcat

 @EnableJpaRepositories("my.package.base.*")
 @ComponentScan(basePackages = { "my.package.base.*" })
 @EntityScan("my.package.base.*")	

I am using spring boot, and when i am using embedded tomcat it was working fine with out @EntityScan("my.package.base.*") but when I tried to deploy the app to an external tomcat I got not a managed type error for my entity.

Extra read:

@ComponentScan is used for scanning all your components those are marked as @Controller, @Service, @Repository, @Component etc…

where as @EntityScan is used to scan all your Entities those are marked @Entity for any configured JPA in your application.

I think replacing @ComponentScan with @ComponentScan("com.nervy.dialer.domain") will work.

Edit :

I have added a sample application to demonstrate how to set up a pooled datasource connection with BoneCP.

The application has the same structure with yours. I hope this will help you to resolve your configuration problems

If you configure your own EntityManagerFactory Bean or if you have copy-pasted such a persistence configuration from another project, you must set or adapt the package in EntityManagerFactory's configuration:

@Bean
public EntityManagerFactory entityManagerFactory() throws PropertyVetoException {
    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setGenerateDdl(true);
    LocalContainerEntityManagerFactoryBean factory;
    factory = new LocalContainerEntityManagerFactoryBean();
    factory.setPackagesToScan("!!!!!!package.path.to.entities!!!!!");
    //...
}

Be careful of the "multiple" needs, you need a String array as the argument passed to setPackagesToScan (and NOT a comma-separated-single-string value). Below illustrates the issue.

    String[] packagesArray = "com.mypackage1,com.mypackage2".split(",");
    em.setPackagesToScan(packagesArray);

In my case the problem was due to my forgetting to have annotated my Entity classes with @javax.persistence.Entity annotation. Doh!

//The class reported as "not a amanaged type"
@javax.persistence.Entity
public class MyEntityClass extends my.base.EntityClass {
    ....
}

I got this error because I stupidly wrote

> public interface FooBarRepository extends CrudRepository<FooBarRepository, Long> { ...

A brief explanation: One typically creates a FooBarRepository class to manage FooBar objects (often representing data in a table called something like foo_bar.) When extending the CrudRepository to create the specialized repository class, one needs to specify the type that's being managed -- in this case, FooBar. What I mistakenly typed, though, was FooBarRepository rather than FooBar. FooBarRepository is not the type (the class) I'm trying to manage with the FooBarRepository. Therefore, the compiler issues this error.

I highlighted the mistaken bit of typing in bold. Delete the highlighted word Repository in my example and the code compiles.

You can use @EntityScan annotation and provide your entity package for scanning all your jpa entities. You can use this annotation on your base application class where you have used @SpringBootApplication annotation.

e.g. @EntityScan("com.test.springboot.demo.entity")

never forget to add @Entity on domain class

Put this in your Application.java file

@ComponentScan(basePackages={"com.nervy.dialer"})
@EntityScan(basePackages="domain")

You either missed @Entity on class definition or you have explicit component scan path and this path does not contain your class

I am using spring boot 2.0 and I fixed this by replacing @ComponentScan with @EntityScan

I had this same problem but only when running spring boot tests cases that required JPA. The end result was that our own jpa test configuration was initializing an EntityManagerFactory and setting the packages to scan. This evidently will override the EntityScan parameters if you are setting it manually.

    final LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter( vendorAdapter );
    factory.setPackagesToScan( Project.class.getPackage().getName());
    factory.setDataSource( dataSource );

Important to note: if you are still stuck you should set a break point in the org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager on the setPackagesToScan() method and take a look at where this is being called and what packages are being passed to it.

I have moved my application class to parent package like :

Main class: com.job.application

Entity: com.job.application.entity

This way you don't have to add @EntityScan

Don't make an obvious mistake like me and get the order of the templated types incorrect. Make sure you don't have the id first in the templated declaration like:

public interface CapacityBasedProductRepository extends JpaRepository<Long, CapacityBasedProduct> {
}

The JPA class is first and the id column type is second like this:

public interface CapacityBasedProductRepository extends JpaRepository<CapacityBasedProduct, Long> {
}

Otherwise you will get it complaining about java.lang.Long being an unknown entity type. It uses the first item to find an entity to use.

I had some problem while migrating from Spring boot 1.3.x to 1.5, I got it working after updating entity package at EntityManagerFactory bean

  @Bean(name="entityManagerFactoryDef")
  @Primary
  public LocalContainerEntityManagerFactoryBean defaultEntityManager() {
      Map map = new HashMap();
      map.put("hibernate.default_schema", env.getProperty("spring.datasource.username"));
      map.put("hibernate.hbm2ddl.auto", env.getProperty("spring.jpa.hibernate.ddl-auto"));
      LocalContainerEntityManagerFactoryBean em = createEntityManagerFactoryBuilder(jpaVendorProperties())
              .dataSource(primaryDataSource()).persistenceUnit("default").properties(map).build();
      em.setPackagesToScan("com.simple.entity");
      em.afterPropertiesSet();
      return em;
  }

This bean referred in Application class as below

@SpringBootApplication
@EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactoryDef")
public class SimpleApp {
  
}

I have the same probblem, in version spring boot v1.3.x what i did is upgrade spring boot to version 1.5.7.RELEASE. Then the probblem gone.

I had this problem because I didn't map all entities in orm.xml file

Below worked for me..

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.apache.catalina.security.SecurityConfig;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.something.configuration.SomethingConfig;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = { SomethingConfig.class, SecurityConfig.class }) //All your configuration classes
@EnableAutoConfiguration
@WebAppConfiguration // for MVC configuration
@EnableJpaRepositories("com.something.persistence.dataaccess")  //JPA repositories
@EntityScan("com.something.domain.entity.*")  //JPA entities
@ComponentScan("com.something.persistence.fixture") //any component classes you have
public class SomethingApplicationTest {

    @Autowired
    private WebApplicationContext ctx;
	private MockMvc mockMvc;

    @Before
	public void setUp() {
    	this.mockMvc = MockMvcBuilders.webAppContextSetup(ctx).build();
	}

    @Test
	public void loginTest() throws Exception {
        this.mockMvc.perform(get("/something/login"))
        .andDo(print()).andExpect(status().isOk());
    }

}

Faced similar issue. In my case the repository and the type being managed where not in same package.

IN CASE YOU ARE WORKING WITH MULTI MODULE SPRING DATA JPA PROJECT.

If you're working with multiple modules and they have Jpa entities and repositories. This may work for you. I used to get a "Not a managed type" error while deployment on external tomcat(never faced in embedded tomcat).

I had 1 main module and 2 other modules as a dependency. When deployed the main project as a war, I could see a total of 3 Spring applications initializing. When the order of execution is the Main module first and then the child module, no error was there. But sometimes, the child module used to get invoked before the main module. which used to cause "Not a managed type Entity exception"

Tricky thing is, the error won't show up in spring boot embedded tomcat. But when we deploy it in an external tomcat. This exception used to come that too randomly. I had to deploy the same war multiple times to get the order right.

I spent the whole day trying to solve the issue. But turned out the problem was with the way I added my other modules as a dependency in the Main module. If you are adding the spring boot module as a dependency in another project, make sure that the main class is not involved in the jar. When you have another spring boot project as a dependency and when you try to deploy the project as a war. The order of execution of the main application class is not guaranteed. Removing the main class will basically avoid the independent execution of child modules. Hence, there won't be any room for order of execution issue.

For future readers:

Here is the syntax sugar for multiple packages to scan.

Note, my two packages are in different jars as well, but package is the primary driver. Just making note of my 2 jar situation.

    em.setPackagesToScan(new String[] {"com.package.ONE.jpa.entities" , "com.package.TWO.jpa.entities"});

My original ERRANT code below:

    em.setPackagesToScan("com.package.ONE.jpa.entities, com.package.TWO.jpa.entities");

What threw me off was my "xml to java-config swapover". The below shows a simple comma separated value.

The comma-separated list seems to work for di.xml, but not "java config".

Java, and it's ::: "when is it comma-separated, when it is a string-array, when is it a string varargs"....... jig saw puzzle drives me nuts sometimes.

    <!-- the value of "id" attribute below MUST BE "entityManagerFactory"  spring-data voodoo -->
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.package.ONE.jpa.entities, com.package.TWO.jpa.entities"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="showSql" value="${spring.jpa.show-sql}"/>
                <property name="generateDdl" value="${spring.jpa.generate-ddl}"/>
            </bean>
        </property>
        <!-- See https://stackoverflow.com/questions/16088112/how-to-auto-detect-entities-in-jpa-2-0/16088340#16088340 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${spring.jpa.hibernate.ddl-auto}</prop>
                <prop key="hibernate.dialect">${spring.jpa.properties.hibernate.dialect}</prop>
            </props>
        </property>
    </bean>

I think it wasn't mentioned by anyone while it's worth noticing that that Not a managed type error might be caused also by package letters case. For example if the package to scan is called myEntities while we provide in package scanning configuration myentities then it might work on one machine while will not work on another so be careful with letter cases.

Adding package to @EntityScan did not help in my case, because there was a factory bean that was specifying packages, so had to add an additional entry there. Then it started working.

another way to solve this issue is ...Package of the class containing @SpringBootApplication should be the root and all other packages should be child. For example:

package com.home

@SpringBootApplication
public class TestApplication{
  springapplication.run....
}
 
package com.home.repo

@Repository
public interface StudentRepo implements JpaRepository<Student, int>{
 ..........
}

package com.home.entity

@Entity
@Table(name = "student")
public class Student{
 ..........
}

I've reproduced similar issue w/ Not a managed type.

More specifically:

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'stockPriceRepository' defined in com.example.stockclient.repository.StockPriceRepository defined in @EnableJpaRepositories declared on StockUiApplication: Invocation of init method failed; nested exception is java.lang.IllegalArgumentException: Not a managed type: class com.example.stockclient.StockPrice

As I had multi-module project, I needed to enable auto configuration support for Spring Data JPA required to know the path of JPA repositories, because by default, it will scan only the main application package and its sub packages for detecting JPA repositories.

So in my specific use case I've already used @EnableJpaRepositories to enable the JPA repositories that contains in necessary packages, but without @EntityScan.

With @EntityScan was the same story as with @EnableJpaRepositories, because entity classes weren't placed in the main application package because of multi-module project.

For more details you can refer, for instance, to this article.

In my case, I was wrongly importing classes from jakarta.persistence-api.

Importing from javax.persistence.* worked for me:

package foo;
import javax.persistence.Entity;

@Entity
@Table(name = "phone_settings", catalog = "dialer")
public class PhoneSettings implements java.io.Serializable {
   // ...
}

If you are using a SessionFactory as an EMF:

In my case the problem was that I forgot to include the new entity type, for which I got the error, as an annotated class in the Hibernate configuration.

So, in your SessionFactory bean, don't forget to include this line for your new entity type:

configuration.addAnnotatedClass(MyEntity.class);