Come posso sovrascrivere un metodo bean di sessione EJB 3 con un argomento generico, se possibile?[Chiuso]

StackOverflow https://stackoverflow.com/questions/14801

Domanda

Supponiamo di avere le seguenti interfacce/classi 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 poi un altro bean che accede a FooRepository fagiolo :

//...
@EJB
private FooRepository fooRepository;

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

Tuttavia, il metodo di override non viene mai eseguito quando viene utilizzato il metodo delete di FooRepository si chiama fagiolo.Invece, solo l'implementazione del metodo delete definito in AbstractRepository viene eseguito.

Cosa sto facendo di sbagliato o è semplicemente una limitazione di Java/EJB 3 che i generici e l'ereditarietà non funzionano ancora bene insieme?

È stato utile?

Soluzione

L'ho provato con un pojo e sembra funzionare.Ho dovuto modificare un po' il tuo codice.Penso che le tue interfacce fossero un po' fuori posto, ma non ne sono sicuro.

Supponevo che "Foo" fosse un tipo concreto, ma in caso contrario posso fare altri test per te.

Ho appena scritto un metodo principale per testarlo.Spero che aiuti!

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);
       }
}

Altri suggerimenti

Puoi scrivere un test unitario sulla tua classe FooRepository semplicemente usandolo come POJO.Se funziona come previsto, non ho familiarità con il motivo per cui funzionerebbe diversamente all'interno di un contenitore.

Sospetto che stia succedendo qualcos'altro e probabilmente sarà più semplice eseguire il debug se lo provi come POJO.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top