Wie kann ich eine EJB 3-Session-Bean-Methode mit einem generischen Argument überschreiben – wenn überhaupt möglich?[geschlossen]

Question

Angenommen, Sie verfügen über die folgenden 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 eine weitere Bean, die auf das zugreift FooRepository Bohne :

//...
@EJB
private FooRepository fooRepository;

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

Die überschreibende Methode wird jedoch niemals ausgeführt, wenn die Löschmethode des FooRepository Bohne heißt.Stattdessen nur die Implementierung der Löschmethode, die in definiert ist AbstractRepository wird ausgeführt.

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

Answer 1

Ich habe es mit einem Pojo versucht und es scheint zu funktionieren.Ich musste deinen Code etwas ändern.Ich denke, Ihre Schnittstellen waren etwas anders, aber ich bin mir nicht sicher.

Ich ging davon aus, dass „Foo“ ein konkreter Typ sei, aber wenn nicht, kann ich weitere Tests für Sie durchführen.

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, dass noch etwas anderes im Gange ist, und das Debuggen wird wahrscheinlich einfacher sein, wenn Sie es als POJO testen.