Wie kann ich eine EJB 3-Session-Bean-Methode mit einem allgemeinen Argument überschreiben - wenn überhaupt?

Question

Angenommen, Sie die folgende EJB 3 Schnittstellen/Klassen:

public interface Repository<E> 
{ 
    public void delete(E entity); 
} 

public abstract class AbstractRepository<E> implements Repository<E> 
{ 
    public void delete(E entity){ 
     //... 
    } 
} 

public interface FooRepository<Foo> 
{ 
    //other methods 
} 

@Local(FooRepository.class) 
@Stateless 
public class FooRepositoryImpl extends 
    AbstractRepository<Foo> implements FooRepository 
{ 
    @Override 
    public void delete(Foo entity){ 
     //do something before deleting the entity 
     super.delete(entity); 
    } 
    //other methods 
} 

Und dann noch eine Bohne, die die FooRepository Bean greift:

//... 
@EJB 
private FooRepository fooRepository; 

public void someMethod(Foo foo) 
{ 
    fooRepository.delete(foo); 
} 
//... 

jedoch die übergeordnete Methode nie ausgeführt wird, wenn die Löschmethode Die FooRepository Bean wird aufgerufen. Stattdessen wird nur die Implementierung der Delete-Methode ausgeführt, die in AbstractRepository definiert ist.

Was mache ich falsch oder ist es einfach eine Einschränkung von Java/EJB 3, dass Generika und Vererbung nicht gut zusammenspielen?

Answer 1

Ich habe es mit einem Pojo versucht und es scheint zu funktionieren. Ich musste deinen Code etwas modifizieren. Ich denke, Ihre Schnittstellen waren ein bisschen aus, aber ich bin mir nicht sicher.

Ich nahm an, "Foo" war ein konkreter Typ, aber wenn nicht, kann ich noch mehr Tests für Sie machen.

Ich habe gerade eine Hauptmethode geschrieben, um dies zu testen. Ich hoffe, das hilft!

public static void main(String[] args){ 
     FooRepository fooRepository = new FooRepositoryImpl(); 
     fooRepository.delete(new Foo("Bar")); 
} 

public class Foo 
{ 
    private String value; 

    public Foo(String inValue){ 
     super(); 
     value = inValue; 
    } 
    public String toString(){ 
     return value; 
    } 
} 

public interface Repository<E> 
{ 
    public void delete(E entity); 
} 

public interface FooRepository extends Repository<Foo> 
{ 
    //other methods 
} 

public class AbstractRespository<E> implements Repository<E> 
{ 
    public void delete(E entity){ 
     System.out.println("Delete-" + entity.toString()); 
    } 
} 

public class FooRepositoryImpl extends AbstractRespository<Foo> implements FooRepository 
{ 
    @Override 
     public void delete(Foo entity){ 
      //do something before deleting the entity 
      System.out.println("something before"); 
      super.delete(entity); 
     } 
} 

Answer 2

Können Sie einen Komponententest für Ihre FooRepository-Klasse schreiben, indem Sie ihn einfach als POJO verwenden. Wenn das wie erwartet funktioniert, kenne ich keinen Grund, warum es in einem Container anders funktionieren würde.

Ich vermute, es ist etwas anderes los und es wird wahrscheinlich einfacher zu debuggen, wenn Sie es als POJO testen.