Comment puis-je remplacer une méthode de bean session EJB 3 par un argument générique - si possible ?[fermé]

Question

Supposons que vous disposiez des interfaces/classes EJB 3 suivantes :

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
}

Et puis un autre bean qui accède au FooRepository haricot :

//...
@EJB
private FooRepository fooRepository;

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

Cependant, la méthode de substitution n'est jamais exécutée lorsque la méthode delete du FooRepository le haricot est appelé.Au lieu de cela, seule l'implémentation de la méthode delete définie dans AbstractRepository est exécuté.

Qu'est-ce que je fais de mal ou est-ce simplement une limitation de Java/EJB 3 qui fait que les génériques et l'héritage ne fonctionnent pas encore bien ensemble ?

Answer 1

Je l'ai essayé avec un pojo et ça semble fonctionner.J'ai dû modifier un peu votre code.Je pense que vos interfaces étaient un peu décalées, mais je n'en suis pas sûr.

J'ai supposé que "Foo" était un type concret, mais sinon je peux faire d'autres tests pour vous.

Je viens d'écrire une méthode principale pour tester cela.J'espère que ça aide!

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

Pouvez-vous écrire un test unitaire sur votre classe FooRepository en l'utilisant simplement comme POJO.Si cela fonctionne comme prévu, je ne connais aucune raison pour laquelle cela fonctionnerait différemment à l'intérieur d'un conteneur.

Je soupçonne qu'il se passe autre chose et il sera probablement plus facile de déboguer si vous le testez en tant que POJO.