Como posso substituir um método de bean de sessão EJB 3 por um argumento genérico - se possível?[fechado]

Question

Suponha que você tenha as seguintes interfaces/classes EJB 3:

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
}

E então outro bean que acessa o FooRepository feijão :

//...
@EJB
private FooRepository fooRepository;

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

No entanto, o método de substituição nunca é executado quando o método delete do FooRepository feijão é chamado.Em vez disso, apenas a implementação do método delete definido em AbstractRepository É executado.

O que estou fazendo de errado ou é simplesmente uma limitação do Java/EJB 3 que genéricos e herança ainda não funcionam bem juntos?

Answer 1

Eu tentei com um pojo e parece funcionar.Tive que modificar um pouco seu código.Acho que suas interfaces estavam um pouco erradas, mas não tenho certeza.

Presumi que "Foo" fosse um tipo concreto, mas se não, posso fazer mais alguns testes para você.

Acabei de escrever um método principal para testar isso.Eu espero que isso ajude!

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

Você pode escrever um teste de unidade em sua classe FooRepository apenas usando-o como um POJO.Se funcionar conforme o esperado, não estou familiarizado com nenhum motivo pelo qual funcionaria de maneira diferente dentro de um contêiner.

Suspeito que haja algo mais acontecendo e provavelmente será mais fácil depurar se você testá-lo como um POJO.