एक अलग मॉड्यूल में इकाइयों के लिए स्कैन करने के लिए हाइबरनेट को कॉन्फ़िगर कैसे करें

Question

मेरे पास मॉड्यूल ए और मॉड्यूल बी है जिसमें दोनों जेपीए एनोटेटेड क्लासेस हैं। मॉड्यूल बी एक इकाई परीक्षण है कि ए दोनों मॉड्यूल ठीक, क्रम निर्भरता, ठीक स्थापित कर रहे हैं संकलन से उन संस्थाओं के एक जोड़े में खींचती है, लेकिन मैं निम्नलिखित त्रुटि मिलती है जब मैं इकाई परीक्षण चलाने का प्रयास:

java.lang.IllegalArgumentException: Unknown entity: MyClassHere 
Caused by: org.hibernate.MappingException: Unknown entity: MyClassHere 

यह EntityManager.merge कॉल में होता है।

चूंकि मॉड्यूल बी में सभी हाइबरनेट कॉन्फ़िगरेशन फ़ाइलें आदि हैं, मुझे लगता है कि यह बस यह नहीं उठा रहा है कि ए से मेरी कक्षा एक इकाई है।

<property name="packagesToScan">myNamespace.*</property> 

फिर

:

मैं

<exclude-unlisted-classes>false</exclude-unlisted-classes> 

persistence.xml को hibernate.cfg.xml में मैं जोड़ा निम्नलिखित जोड़ने की कोशिश की

<property name="packagesToScan"> 
       <array> 
        <value>myNamespace.*</value> 
       </array> 
</property> 

जो मुझे एक त्रुटि दे दी है "संपत्ति" की सामग्री शून्य से मेल खाना चाहिए। फिर मैंने कोशिश की:

<mapping class="myNamespace.*" /> 

मुझे क्या याद आ रही है?

संपादित करें: एक बात जिसे मैं उल्लेख करना भूल गया था, यह महत्वपूर्ण हो सकता है कि दो मॉड्यूल अलग परियोजनाओं के रूप में स्थापित किए गए हैं (मैं ग्रहण का उपयोग कर रहा हूं) ताकि निर्देशिका संरचना अलग हो। रन टाइम निर्भरता सभी ठीक से सेट की गई हैं, लेकिन चूंकि .class फ़ाइलें अलग-अलग निर्देशिकाओं में समाप्त होती हैं, इसलिए मुझे लगता है कि हाइबरनेट उनको स्कैन नहीं कर सकता है।

Answer 1

यदि आप अपनी परियोजना को इकाइयों को स्वत: पहचानने के लिए कॉन्फ़िगर करते हैं, तो यह केवल उस पथ को स्कैन करेगा जहां मेटा-आईएनएफ/persistence.xml (डिफ़ॉल्ट रूप से) है।

के अलावा:

<property name="hibernate.archive.autodetection" value="class, hbm" /> 

यह निर्धारित करता है जो तत्व हाइबरनेट इकाई प्रबंधक द्वारा की खोज की ऑटो है:

<exclude-unlisted-classes>false</exclude-unlisted-classes> 

आप एक अतिरिक्त हाइबरनेट विकल्प सेट।

अतिरिक्त इकाइयों के लिए (दूसरों के जार में) आप अपने मुख्य persistence.xml फ़ाइल में जार फ़ाइल खंड सेट कर सकते हैं:

<persistence> 
    <persistence-unit name="myUnit"> 
     ... 
     <class>foo.bar.Entity1</class> 
     <class>foo.bar.Entity2</class> 
     <jar-file>moduleB.jar</jar-file> 
     ... 
    </persistence-unit> 
</persistence> 

जार-जार फ़ाइल तत्व फ़ाइलें जो करने के लिए दिखाई दे रहे हैं निर्दिष्ट करता है पैक किए गए दृढ़ता इकाई जिसमें प्रबंधित दृढ़ता वर्ग होते हैं, जबकि वर्ग तत्व स्पष्ट रूप से प्रबंधित दृढ़ता वर्गों का नाम देता है।

जेएआर फ़ाइल या निर्देशिका जिसका मेटा-आईएनएफ निर्देशिका में persistence.xml को दृढ़ता इकाई की जड़ कहा जाता है। दृढ़ता इकाई का दायरा दृढ़ता इकाई की जड़ द्वारा निर्धारित किया जाता है। प्रत्येक दृढ़ता इकाई को उस नाम से पहचाना जाना चाहिए जो दृढ़ता इकाई के दायरे के लिए अद्वितीय है।

सादर, आन्द्रे

Answer 2

persistence.xml <jar-file>....jar</jar-file> तत्व हो सकते हैं: एक या अधिक जार फ़ाइलों को कक्षाओं के लिए खोज की जाएगी निर्दिष्ट करता है।

Answer 3

हमने परियोजनाओं पर पता लगाने के लिए Spring का उपयोग कर इस परियोजना पर एक समान समस्या हल की है। जैसे व्याख्या किए गए स्प्रिंग विन्यास का उपयोग कर:

@Configuration 
@ComponentScan("com.org.prj.myNamespace1", "com.org.prj.myNamespace2") 
public class MyDatabaseConfig { 
    @Bean 
    public EntityManagerFactory entityManagerFactory() { 
     final LocalContainerEntityManagerFactoryBean factory = 
      new LocalContainerEntityManagerFactoryBean(); 

     // ...JPA properties, vendor adaptor, dialect, data source, persistence unit etc... 

     factory.setPackagesToScan("com.org.prj.myNamespace1", "com.org.prj.myNamespace2"); 

     factory.afterPropertiesSet(); 
     return factory.getObject(); 
    } 

    // ...Data source beans etc... 
} 

Answer 4

मैं हाल ही में एक ऐसी ही समस्या हल हो, persistence.xml

<jar-file>file:///C:/yourpath/yourJar.jar</jar-file>

आशा है कि यह मदद करता है फाइल करने के लिए जार पथ को जोड़ने।  

Answer 5

• आप हाइबरनेट उपयोग कर रहे हैं/वसंत हम LocalSessionFactoryBean वस्तु का विस्तार करने और करने के लिए परियोजना के माध्यम से स्कैन परियोजना में इकाई वर्ग की पहचान कर सकते हैं।
• चूंकि आप दो अलग-अलग परियोजनाओं को कह रहे हैं, तो दो परियोजनाओं को पार्स करने के लिए कुछ बिल्ड टाइम उपयोगिता लिखने का प्रयास करें और अपनी समस्या को हल करने वाली इकाई xml फ़ाइल बनाई है।

Answer 6

• src/मुख्य/संसाधन: applicationContext.xml
• src/परीक्षण/संसाधन: परीक्षण applicationContext.xml

आप भी अपने आवेदन के बनाने के परीक्षण दायरे में सुनिश्चित करें उन संस्थाओं के लिए स्कैन करने के लिए संदर्भ। आपका test-applicationContext.xml पूरे एप्लिकेशन-संदर्भ को रनटाइम पर सेट अप नहीं कर सकता है, लेकिन परीक्षण-समय पर कुछ चीजों की भी आवश्यकता होती है, जैसे आपके पैकेज-स्कैनिंग भी शामिल होनी चाहिए।

आप बिल्कुल दोनों applicationContext.xml और परीक्षण applicationContext.xml

Answer 7

सरल तरीके से src/मुख्य/संसाधनों में persistence.xml बनाने और इसे शामिल कर सकते हैं करने के लिए है कि

configuration.addAnnotatedClass(Contact.class) 

यदि आप पैकेज द्वारा स्कैन का उपयोग करना चाहते हैं, तो पहले ClassLoader का उपयोग करके सभी वर्गों को लोड करें। आप वसंत का उपयोग कर रहे Hibernate-orm LocalSessionFactoryBuilder.class

@Bean 
public SessionFactory sessionFactory(){ 

    HibernateConfig configuration = new HibernateConfig(); 

    Properties properties = hibernateProperties(); 

    configuration.setProperties(properties); 

    configuration.scanPackages("com.atcc.stom.model.entity"); 

    return configuration.buildSessionFactory(); 
} 

HibernateConfig.class

import org.hibernate.HibernateException; 
import org.hibernate.MappingException; 
import org.hibernate.cfg.Configuration; 
import org.springframework.core.io.Resource; 
import org.springframework.core.io.ResourceLoader; 
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; 
import org.springframework.core.io.support.ResourcePatternResolver; 
import org.springframework.core.io.support.ResourcePatternUtils; 
import org.springframework.core.type.classreading.CachingMetadataReaderFactory; 
import org.springframework.core.type.classreading.MetadataReader; 
import org.springframework.core.type.classreading.MetadataReaderFactory; 
import org.springframework.core.type.filter.AnnotationTypeFilter; 
import org.springframework.core.type.filter.TypeFilter; 
import org.springframework.util.ClassUtils; 

import javax.persistence.AttributeConverter; 
import javax.persistence.Embeddable; 
import javax.persistence.Entity; 
import javax.persistence.MappedSuperclass; 
import java.io.IOException; 
import java.lang.annotation.Annotation; 
import java.util.Set; 
import java.util.TreeSet; 

public class HibernateConfig extends Configuration { 

    private static final TypeFilter[] DEFAULT_ENTITY_TYPE_FILTERS = new TypeFilter[] { 
      new AnnotationTypeFilter(Entity.class, false), 
      new AnnotationTypeFilter(Embeddable.class, false), 
      new AnnotationTypeFilter(MappedSuperclass.class, false)}; 

    private static final String RESOURCE_PATTERN = "/**/*.class"; 

    private static final String PACKAGE_INFO_SUFFIX = ".package-info"; 

    private final ResourcePatternResolver resourcePatternResolver; 

    private static TypeFilter converterTypeFilter; 

    static { 
     try { 
      @SuppressWarnings("unchecked") 
      Class<? extends Annotation> converterAnnotation = (Class<? extends Annotation>) 
        ClassUtils.forName("javax.persistence.Converter", Configuration.class.getClassLoader()); 
      converterTypeFilter = new AnnotationTypeFilter(converterAnnotation, false); 
     } 
     catch (ClassNotFoundException ex) { 
      // JPA 2.1 API not available - Hibernate <4.3 
     } 
    } 

    public HibernateConfig() { 
     this(new PathMatchingResourcePatternResolver()); 
    } 

    public HibernateConfig(ClassLoader classLoader) { 
     this(new PathMatchingResourcePatternResolver(classLoader)); 
    } 

    public HibernateConfig(ResourceLoader resourceLoader) { 
     this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); 
    } 

    public void scanPackages(String... packagesToScan) throws HibernateException { 
     Set<String> entityClassNames = new TreeSet<String>(); 
     Set<String> converterClassNames = new TreeSet<String>(); 
     Set<String> packageNames = new TreeSet<String>(); 
     try { 
      for (String pkg : packagesToScan) { 
       String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + 
         ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN; 

       Resource[] resources = this.resourcePatternResolver.getResources(pattern); 
       MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver); 
       for (Resource resource : resources) { 
        if (resource.isReadable()) { 
         MetadataReader reader = readerFactory.getMetadataReader(resource); 
         String className = reader.getClassMetadata().getClassName(); 
         if (matchesEntityTypeFilter(reader, readerFactory)) { 
          entityClassNames.add(className); 
         } 
         else if (converterTypeFilter != null && converterTypeFilter.match(reader, readerFactory)) { 
          converterClassNames.add(className); 
         } 
         else if (className.endsWith(PACKAGE_INFO_SUFFIX)) { 
          packageNames.add(className.substring(0, className.length() - PACKAGE_INFO_SUFFIX.length())); 
         } 
        } 
       } 
      } 
     } 
     catch (IOException ex) { 
      throw new MappingException("Failed to scan classpath for unlisted classes", ex); 
     } 
     try { 
      ClassLoader cl = this.resourcePatternResolver.getClassLoader(); 
      for (String className : entityClassNames) { 
       addAnnotatedClass(cl.loadClass(className)); 
      } 
      for (String className : converterClassNames) { 
       ConverterRegistrationDelegate.registerConverter(this, cl.loadClass(className)); 
      } 
      for (String packageName : packageNames) { 
       addPackage(packageName); 
      } 
     } 
     catch (ClassNotFoundException ex) { 
      throw new MappingException("Failed to load annotated classes from classpath", ex); 
     } 
    } 

    private boolean matchesEntityTypeFilter(MetadataReader reader, MetadataReaderFactory readerFactory) throws IOException { 
     for (TypeFilter filter : DEFAULT_ENTITY_TYPE_FILTERS) { 
      if (filter.match(reader, readerFactory)) { 
       return true; 
      } 
     } 
     return false; 
    } 

    /** 
    * Inner class to avoid hard dependency on JPA 2.1/Hibernate 4.3. 
    */ 
    private static class ConverterRegistrationDelegate { 

     @SuppressWarnings("unchecked") 
     public static void registerConverter(Configuration config, Class<?> converterClass) { 
      config.addAttributeConverter((Class<? extends AttributeConverter<?, ?>>) converterClass); 
     } 
    } 

}