Java EE 6 @javax.annotation.ManagedBean vs @javax.injecter.Nommé vs @javax.face.ManagedBean

tout d'abord laissez-moi faire quelques clarifications:

haricot contrôlé définition : généralement, un haricot contrôlé est un objet dont le cycle de vie (construction, destruction, etc.) est géré par un contenant.

en Java ee nous avons de nombreux conteneurs qui gèrent le cycle de vie de leurs objets, comme JSF conteneur, EJB conteneur, CDI conteneur, Servlet conteneur, etc.

tous ces conteneurs fonctionnent en quelque sorte indépendants, ils initialisent l'initialisation du serveur d'application et scannent les classes de tous les artefacts, y compris jar, ejb-jar, les fichiers war et ear en temps de déploiement et rassemblent et stockent des métadonnées à leur sujet, puis quand vous avez besoin d'un objet d'une classe à l'exécution, ils vous donneront des instances de ces classes et après avoir terminé le travail, ils les détruiront.

Donc, nous pouvons dire que nous avons:

• JSF managed beans
1519310920 "fèves gérées par le CDI
• EJB managed beans
• et même Servlets sont gérés haricots parce qu'ils sont instanciés et détruits par un conteneur, qui est un conteneur de servlets.

ainsi quand vous voyez le mot Bean géré, vous devriez demander sur le contexte ou le type de celui-ci.(JSF, CDI, EJB, etc.)

alors vous pourriez demander pourquoi nous avons beaucoup de ces conteneurs: AFAIK, Java EE gars ont voulu ont un cadre d'injection de dépendances, mais ils n'ont pas pu rassembler toutes les exigences dans une spécification parce qu'ils ne pouvaient pas prédire les exigences futures et ils ont fait EJB 1.0 et puis 2.0 et puis 3.0 et maintenant 3.1 mais la cible D'EJB était pour quelques exigences seulement (transaction, modèle de Composant distribué, etc).

en même temps (en parallèle) ils ont réalisé qu'ils ont besoin de soutenir JSF aussi, puis ils ont fait JSF haricots gérés et un autre conteneur pour JSF haricots et ils considéraient qu'il s'agissait d'un conteneur mature DI, mais il n'était pas encore complet et mature.

après que Gavin King et quelques autres gars sympas;) fait CDI qui est le plus mature di conteneur que j'ai vu. Le CDI (inspiré de Seam2, Guice et Spring) a été conçu pour combler le vide entre JSF et EJB et beaucoup d'autres choses utiles comme l'injection pojo, les méthodes de production, les intercepteurs, les décorateurs, l'intégration SPI, très flexible, etc. et il peut même faire ce que L'EJB et JSF ont géré les haricots font alors nous pouvons avoir juste un récipient de DI mûr et puissant. Mais pour des raisons de compatibilité rétrograde et des raisons politiques Java EE gars veulent les garder!!!

ici vous pouvez trouver la différence et utiliser des étuis pour chacun de ces types:

JSF Géré les Haricots, les CDI, les Haricots et les Ejb

JSF a été initialement développé avec son propre mécanisme géré d'injection de haricots et de dépendance qui a été amélioré pour le JSF 2.0 afin d'inclure les haricots annotés. Lorsque le CDI a été lancé avec Java EE 6, Il a été considéré comme le cadre bean géré pour cette plate-forme et, bien sûr, EJBs obsolète tous les ayant été autour de bien plus d'une décennie.

le problème est bien sûr de savoir qui utiliser et quand les utiliser.

commençons par le plus simple, JSF Managed beans.

JSF Managed Beans

en bref, ne les utilisez pas si vous développez pour Java EE 6 et utilisez CDI. Ils fournissent un mécanisme simple pour l'injection de dépendances et la définition des fèves de renfort pour les pages web, mais ils sont beaucoup moins puissants que les fèves CDI.

ils peuvent être définis en utilisant l'annotation @javax.faces.bean.ManagedBean qui prend un paramètre de nom optionnel. Ce nom peut être utilisé pour faire référence au haricot des pages JSF.

peut être appliqué à la fève en utilisant l'une des différentes portées définies dans le paquet javax.faces.bean qui inclut les portées request, session, application, view et custom.

@ManagedBean(name="someBean")
@RequestScoped
public class SomeBean {
    ....
    ....
}

JSF haricots ne peut pas être mélangé avec d'autres sortes de haricots sans une sorte de manuel de codage.

CDI Haricots

CDI est le bean management and dependency injection framework qui a été publié dans le cadre de Java EE 6 et il comprend un installation complète et complète de gestion des haricots. Les fèves CDI sont beaucoup plus évoluées et flexibles que les fèves JSF simples gérées. Ils peuvent faire usage d'intercepteurs, de portée de conversation, D'événements, d'injection sécuritaire, de décorateurs, de stéréotypes et de méthodes de production.

pour déployer des haricots CDI, vous devez placer un fichier appelé haricots.xml dans un dossier META-INF sur classpath. Une fois que vous faites cela, alors chaque haricot dans le paquet devient un haricot CDI. Il y a beaucoup de fonctionnalités dans le CDI, trop de couvrez ici, mais comme une référence rapide pour les fonctionnalités de type JSF, vous pouvez définir le champ D'application du CDI en utilisant l'un des champs définis dans le paquet javax.enterprise.context (à savoir, les champs requête, conversation, session et application). Si vous voulez utiliser la fève CDI d'une page JSF, vous pouvez lui donner un nom en utilisant l'annotation javax.inject.Named . Pour injecter un haricot dans un autre haricot, vous annotez le champ avec l'annotation javax.inject.Inject .

@Named("someBean")
@RequestScoped
public class SomeBean {

    @Inject
    private SomeService someService;
}

injection automatique comme ça défini ci-dessus peut être contrôlé par l'utilisation de Qualificatifs qui peuvent aider à correspondre à la catégorie spécifique que vous voulez injectée. Si vous avez plusieurs types de paiement, vous pouvez ajouter un qualificatif pour savoir s'il est asynchrone ou non. Alors que vous pouvez utiliser l'annotation @Named comme un qualificatif, vous ne devriez pas car il est prévu pour exposer les haricots dans EL.

CDI s'occupe de l'injection des haricots avec des lunettes de visée mal assorties à l'aide de procurations. De ce fait, vous pouvez injecter un requête scoped bean dans une session scoped bean et la référence sera toujours valide sur chaque requête car pour chaque requête, le proxy se connecte de nouveau à une instance live de la requête scoped bean.

CDI a également le soutien pour les intercepteurs, les événements, le nouveau cadre de conversation et de nombreuses autres fonctionnalités qui en fait un bien meilleur choix que les haricots JSF gérés.

EJB

les Ejb sont antérieurs CDI haricots et sont en quelque sorte similaires aux haricots du CDI et d'autres façons très différentes. Principalement, la différence entre les haricots CDI et les haricots EJBs est que les EJBs sont:

• Transactionnelle
• en local ou à Distance
• capable de passiver des haricots d'état libérant des ressources
• capable d'utiliser des minuteries
• peut être asynchrone

les deux types d'EJBs sont appelés apatrides et stateful. Les EJB apatrides peuvent être considérés comme des haricots à usage unique et sans danger qui ne maintiennent aucun État entre deux requêtes web. Les EJB Stateful tiennent l'état et peuvent être créés et s'asseoir autour aussi longtemps qu'ils sont nécessaires jusqu'à ce qu'ils soient éliminés.

définir une EJB est simple, il suffit d'ajouter une annotation javax.ejb.Stateless ou javax.ejb.Stateful à la classe.

@Stateless
public class BookingService {

  public String makeReservation(Item Item, Customer customer) {
    ...
    ...
  }
}

les haricots apatrides doivent avoir une dépendance portée alors qu'un haricot de session stateful peut avoir n'importe quelle portée. Par défaut, ils sont transactionnelles, mais vous pouvez utiliser l'attribut transaction d'annotation.

alors que les haricots EJBs et CDI sont très différents en termes de caractéristiques, l'écriture du code pour les intégrer est très similaire car les haricots CDI peuvent être injectés dans les grains EJBs et les grains EJBs peuvent être injectés dans les grains CDI. Il n'est pas nécessaire de faire de distinction lors de l'injection de l'un dans l'autre. Encore une fois, les différents champs d'application sont gérés par le CDI. grâce à l'utilisation de proxy. Une exception à cela est que le CDI ne supporte pas l'injection d'EJBs à distance mais qui peut être implémentée en écrivant une méthode simple de producteur pour cela.

l'annotation javax.inject.Named ainsi que tout qualificatif peuvent être utilisés sur un EJB pour l'apparier à un point d'injection.

quand utiliser quel haricot

Comment savoir quand utiliser quel haricot? Simple.

N'utilisez jamais de haricots JSF managés à moins que vous ne travailliez dans un container servlet et que vous ne vouliez pas essayer de faire travailler le CDI à Tomcat (bien qu'il y ait quelques archétypes Maven pour cela donc il n'y a pas d'excuse).

en général, vous devez utiliser CDI beans à moins que vous n'ayez besoin des fonctionnalités avancées disponibles dans les EJBs telles que les fonctions transactionnelles. Vous pouvez écrire votre propre intercepteur pour rendre les fèves CDI transactionnel, mais pour l'instant, il est plus simple d'utiliser un EJB jusqu'à ce que le CDI obtient des haricots CDI transactionnel qui est juste au coin. Si vous êtes coincé dans un conteneur servlet et que vous utilisez le CDI, alors les transactions écrites à la main ou votre propre intercepteur de transaction est la seule option sans EJBs.

si vous devez utiliser @ViewScoped dans CDI vous devez

• utiliser couture-faces ou MyFaces CODI module. il suffit d'ajouter un à votre classpath et @ViewScoped travaillera au CDI. MyFaces CODI a un support encore plus solide de @ViewScoped
• utiliser le code de MyFaces @ViewAccessScoped , c'est une extension écrite sur le dessus de CDI par Apache, juste télécharger it et utiliser @ViewAccessScoped annotation au lieu de @ViewScoped .
• utiliser CDI @ConversationScoped et le faire à long terme. Voir ici pour plus d'informations .
• Utiliser Omnifaces @ViewScoped annotation

certaines parties ont été volées de ici .