Use Of Contexts And Dependency Injection In Java Ee 6

By Author: mayur aegis
Total Articles: 64
Comment this article

The use of Contexts and dependency injection in Java EE 6 is discussed here. The dependency injection model is made more flexible and powerful compared to the earlier version. J2ee developments by J2ee developers are able to provide any type of complex applications and web projects with the use of such powerful features.
Configuration of DI:
EJB 3 DI is very user-friendly and requires single annotation which results into injection of declared bean. After the injected bean it could be either an interface or a no-interface one. No ceremony is required to inject until there is only one implementation. If you want to disambiguate the choice then only you require configuring.
Two implementations of interface if exists then can break the convention and it throws an exception while deploying the app. At this time annotation with the beanName attribute fixes any issue.Configuration of DI is also possible in the deployment descriptor instead of annotations. This is still string based and here only string matching implementing option can be done.
Introduction of EJB Reference: When there is no-interface view then ...
... neither the bean nor the injected instance is the implementation of interface. Specification of Java EE is not prescribing the injected class’s nature and it does only the implementation indirection usage. Custom features like interceptors, transaction, concurrency, security, management and monitoring is handled by EJB container for transparent processes by you. All these features are implemented with an indirection.
EJB 3 DI is easy to use in J2ee development. J2ee developers name annotation and beans which is describing what the client’s side of behaviour is for beans. When it is stateless then there is no definition between the proxy and actual bean instance. Clients are facilitated with sharing between them with EJB instance. The clients on opposite side if eager can overload the server and communicate with several instances with the help of same proxy. In stateless condition clients do not have any control during the bean lifecycle and here the total management is done by container. Injection container creates bean here. Client initiates destructive invocation in the business method if annotation or container-specific timeout is the reason. In case of stateful bean it can be injected into a stateless bean but here you will get unpredictable or unexpected results. Here the stateful one bounds to the stateless bean instance. Beans are the ones that are un-aware of everything that happens from the servlet specifications. EJB does not allow automating the association of Http session and stateful instance.
CDI and C: CDI is a fresh specification launched in Java EE 6 that gives us a definition of powerful and type-safe dependency injection. At the same time it brings also the concept of contextual scopes or references. Beans totally differ from EJB here due to C as here they are CDI beans which are managed ones and those were not. Their scope is well defined so as to create as well as destroy on demand by the container. It already possesses pre-defined scopes and annotations. This container helps in managing all beans inside the scope automatically. Lastly also the http session, instances that associates with this scope are destroyed automatically and collects as garbage.
Thus a correct way for qualification and configuration of dependencies here is typing of annotations with the help of optional attributes and not with plain strings.

For More Information:- J2ee Development | JEE Developers