Comment remplacer une méthode de bean session EJB 3 par un argument générique, si possible?

Question

Supposons que vous ayez l'EJB après 3 interfaces/classes:

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 haricot qui accède à la fève FooRepository:

//... 
@EJB 
private FooRepository fooRepository; 

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

Cependant, la méthode redéfinie est jamais exécuté lorsque la méthode de suppression de le bean FooRepository est appelé. Au lieu de cela, seule l'implémentation de la méthode de suppression définie dans AbstractRepository est exécutée.

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

Answer 1

Je l'ai essayé avec un pojo et cela semble fonctionner. J'ai dû modifier un peu votre code. Je pense que vos interfaces étaient un peu en retrait, mais je ne suis pas sûr. Je supposais que "Foo" était un type concret, mais sinon je peux faire plus de tests pour vous.

Je viens d'écrire une méthode principale pour tester cela. J'espère que cela 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 contre votre classe FooRepository en l'utilisant comme POJO. Si cela fonctionne comme prévu, je ne connais pas pourquoi il fonctionnerait différemment dans un conteneur.

Je suppose qu'il se passe quelque chose d'autre et il sera probablement plus facile à déboguer si vous le testez comme un POJO.