webentwicklung-frage-antwort-db.com.de

Spring Boot - Kein verwalteter Typ

Ich verwende Spring Boot + JPA und habe ein Problem beim Starten des Dienstes.

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)

Hier ist die Application.Java-Datei,

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

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

Ich verwende UCp für das Verbindungs-Pooling und die DataSource-Konfiguration ist unten,

@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;

Implementierung von UserDetailsService,

@Service("userDetailsService")
@SessionAttributes("user")
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserService userService;

Service-Layer-Implementierung,

@Service
public class PhoneSettingsServiceImpl implements PhoneSettingsService {

}

Die Repository-Klasse,

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

}

Entitätsklasse,

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

WebSecurityConfig-Klasse,

@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());
    }

}

Die Pakete sind wie folgt:

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

Vielen Dank

90
user1578872

Ich denke, das Ersetzen von @ComponentScan Durch @ComponentScan("com.nervy.dialer.domain") wird funktionieren.

Bearbeiten:

Ich habe ein Beispielanwendung hinzugefügt, um zu demonstrieren, wie eine gepoolte Datenquellenverbindung mit BoneCP eingerichtet wird.

Die Anwendung hat dieselbe Struktur wie Ihre. Ich hoffe, dies wird Ihnen helfen, Ihre Konfigurationsprobleme zu lösen

39
azizunsal

Konfigurieren Sie die Position von Entitäten mithilfe von @ EntityScan in der Spring Boot-Einstiegspunktklasse.

Update vom September 2016 : Für Spring Boot 1.4+:
verwenden org.springframework.boot.autoconfigure.domain.EntityScan
anstatt org.springframework.boot.orm.jpa.EntityScan, as ... boot.orm.jpa.EntityScan ist veraltet ab Spring Boot 1.4

86

Versuchen Sie Folgendes hinzuzufügen: In meiner Anwendung funktioniert es einwandfrei mit Tomcat

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

Ich verwende Spring Boot, und wenn ich Embedded Tomcat verwende, funktioniert es ohne @EntityScan("my.package.base.*"), aber als ich versuchte, die App auf einem externen Tomcat bereitzustellen, wurde für meine Entität ein not a managed type - Fehler angezeigt .

58
manoj

In meinem Fall lag das Problem daran, dass ich vergessen hatte, meine Entity-Klassen mit @ javax.persistence.Entity-Annotation zu kommentieren. Doh!

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

Sie können die Annotation @ EntityScan verwenden und Ihr Entitätspaket zum Scannen aller Ihrer JPA-Entitäten bereitstellen. Sie können diese Annotation in Ihrer Basisanwendungsklasse verwenden, in der Sie die Annotation @SpringBootApplication verwendet haben.

z.B. @ EntityScan ("com.test.springboot.demo.entity")

14
Nitesh Saxena

vergessen Sie niemals, @Entity für die Domain-Klasse hinzuzufügen

Entweder haben Sie @Entity bei der Klassendefinition verpasst, oder Sie haben einen expliziten Pfad für die Komponentensuche, und dieser Pfad enthält Ihre Klasse nicht

5
Tamer Awad

Wenn Sie die Persistenzkonfiguration aus einem anderen Projekt kopiert haben, müssen Sie das Paket in EntityManagerFactory manuell festlegen:

    @Bean
    public EntityManagerFactory entityManagerFactory() throws PropertyVetoException {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(true);

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setPackagesToScan("!!!!!!misspelled.package.path.to.entities!!!!!");

        ....
    }
4
Lazaruss

Ich habe das gleiche Problem, in der Version Spring Boot v1.3.x habe ich Spring Boot auf Version 1.5.7.RELEASE aktualisiert. Dann ist das Problem weg.

0
Maosheng Wang

Unten hat bei mir gearbeitet ..

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());
}

}

0
Debadatta