Un bean EJB3 peut-il s'auto-injecter et appeler ses propres méthodes via un conteneur EJB?

Question

Est-il possible de "s'injecter soi-même" un EJB pour appeler des méthodes locales comme méthodes de haricot? Dans certains cas, cela pourrait être favorable, par exemple si des transactions gérées par des conteneurs sont utilisées et que quelque chose devrait être accompli dans une nouvelle transaction.

Un exemple comment cela pourrait fonctionner:

Foo.java:

@Local 
public interface FoO { 
    public void doSomething(); 
    public void processWithNewTransaction(); // this should actually be private 
} 

FooBean.java:

@Stateless 
public class FooBean implements Foo { 

    @EJB 
    private Foo foo; 

    public void doSomething() { 
     ... 
     foo.processWithNewTransaction(); 
     ... 
    } 

    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void processWithNewTransaction() { 
     ... 
    } 
} 

Si j'extrais processWithNewTransaction() à un autre grain, il aurait besoin d'être exposée comme une méthode publique dans l'interface, même si elle doit être appelée uniquement par FooBean. (Le même problème concerne mon code ci-dessus, c'est pourquoi il y a un commentaire dans la définition de l'interface.)

Une solution consisterait à basculer vers des transactions gérées par le bean. Cependant, cela nécessiterait de changer le bean entier pour gérer ses propres transactions, et ajouterait beaucoup de plaque de chaudière à toutes les méthodes.

Answer 1

Mise à jour: Comme cela est indiqué par d'autres réponses, cela est techniquement possible. S'il vous plaît voir les réponses de Csaba et Michael sur comment et pourquoi cela fonctionne malgré la récurrence sans fin apparente.

---

Je ne peux pas donner une réponse précise à 100% mais je suis à peu près sûr que ce n'est pas possible. Je pense que parce que pour injecter le bean Foo dans le haricot Foo lui-même, le conteneur devrait initialement créer une instance de Foo qu'il pourra ensuite injecter. Mais pour créer ceci il doit injecter une instance déjà existante de Foo dans le Foo à créer ... ce qui conduit à une récursion infinie.

Si vous avez besoin de transactions séparées, je vous suggère de garder les choses simples et de créer deux beans/interfaces indépendants.

Answer 2

Question intéressante. Je ne crée jamais une méthode avec un attribut de transaction différent dans le même bean, c'est-à-dire que cela nécessite un refactoring. Cela rend généralement difficile la détection de bogues dans l'application lorsqu'elle évolue.

EDIT: fautes de frappe fixe

Answer 3

Je suis pas d'accord, il est souvent utile pour la gestion des transactions pour appeler une méthode de haricot local via le conteneur. Exactement comme exemple si vous deviez appeler une méthode de bean locale dans une boucle, mieux vaut une transaction par itération que pour toutes les itérations. (à condition que la logique métier ne soit pas «tout ou rien», comme l'envoi d'une livraison ou l'émission d'actions)

Answer 4

L'auto-injection d'un EJB est en effet possible. La raison pour laquelle une récursion infinie ne se produira pas dans ce cas est assez simple: le conteneur n'injecte pas une instance de bean réelle du pool. Au lieu de cela, il injecte un objet proxy. Lorsque vous appelez une méthode sur le proxy injecté (foo), le conteneur obtient une instance de bean de son pool ou en crée une, s'il n'y a pas d'instances disponibles.

Answer 5

Il est possible de faire self injection. Vous devez utiliser SessionContext.

SessionContext sc = ... 
sc.getBusinessObject(FooBean.class).processWithNewTransaction()