Description Blazej Kroll 2009-07-16 06:40:31 EDT

Created attachment 141752 [details]
simplest project to recreate the problem without hibernate jars (to be included)

STEPS TO REPRODUCE ON AN EMPTY WORKSPACE:                                

1. Create new EAR 1.4 targeting WAS 6.1: "SimplestEAR"                   

2. Create new  Dynamic Web Module "SimplestDummyWeb"                     

3. Add to the root directory of the EAR the following jars:              

hibernate-annotations-3.4GA.jar                                          
hibernate-commons-annotations-3.3.1.jar                                  
hibernate-core-3.3.1GA.jar                                               
hibernate-entitymanager-3.4.jar                                          
hibernate-validator-3.1.0GA.jar                                          

(probably only the first three are actually needed)                      

4. Create a Java project "JavaProjBase" containing the following class:  
-----------------------                                                  
package types;                                                           

public class Type1 {                                                     

}                                                                        
-----------------------                                                  
Export it as a jar file called: "java-proj-base.jar"                     

5. Add this jar to the root directory of the EAR                         

6. Create a Java Utility Project "JavaProjUtil" with following           
classpath:                                                               

<?xml version="1.0" encoding="UTF-8"?>                                   
<classpath>                                                              
 <classpathentry kind="src" path="src"/>                                 
 <classpathentry kind="con"                                              
path="org.eclipse.jdt.launching.JRE_CONTAINER"/>                         
 <classpathentry combineaccessrules="false" kind="src"                   
path="/JavaProjBase"/>                                                   
 <classpathentry kind="con"                                              
path="org.eclipse.jst.j2ee.internal.module.container"/>                  
 <classpathentry kind="output" path="bin"/>                              
</classpath>                                                             


and MANIFEST.MF                                                          

Manifest-Version: 1.0                                                    
Class-Path: java-proj-util.jar                                           
 hibernate-annotations-3.4GA.jar                                         

7. Add the following class to this project:                              
-----------------                                                        
package utils;                                                           

@org.hibernate.annotations.TypeDefs(                                     
  value={                                                                
    @org.hibernate.annotations.TypeDef(name="Type1",                     
        typeClass=types.Type1.class),                                    
      })                                                                 

public class Util1 {                                                     


}                                                                        
----------------                                                         

THE TRICK IS THE TYPE OF REFERENCE FROM Util1 to Type1, via the          
ANNOTATION.                                                              

8. Export the above project as jar, reusing the existing MANIFEST:       

java-proj-util.jar                                                       

9.  Add to the EAR the following jars:                                   

java-proj-util.jar                                                       

10. Add to the Java EE Module dependencies of the project                
"SimplestDummyWeb" the                                                   

java-proj-util.jar                                                       

11. Add to "SimplestDummyWeb" the following Java file:                   
-------------                                                            
package com;                                                             

import utils.Util1;                                                      

public class Class2 {                                                    

 Util1 myUtil;                                                           

 Util1 doSomething(Util1 util1){                                         
  return new Util1();                                                    
 };                                                                      

}                                                                        
-------------                                                            
Result:                                                                  

You have no errors in problem view nor in Enterprise Explorer/Project    
Explorer/Navigator.                                                      

However, when you open the file in the Java editor you get the error:    

"The type types.Type1 cannot be resolved. It is indirectly referenced    
from required .class files"     

The simple project is attached SimplestCorrectedPI_withoutHibernateJars -
without hibernate jars (which need to be included).