{"id":3849,"date":"2012-02-22T12:50:09","date_gmt":"2012-02-22T17:50:09","guid":{"rendered":"http:\/\/jianmingli.com\/wp\/?p=3849"},"modified":"2012-06-16T08:10:13","modified_gmt":"2012-06-16T13:10:13","slug":"cdi-context-and-dependency-injection-jsr-299","status":"publish","type":"post","link":"https:\/\/jianmingli.com\/wp\/?p=3849","title":{"rendered":"CDI: Context and Dependency Injection (JSR-299)"},"content":{"rendered":"
\n

Contents<\/h2>\n
    \n\t
  1. \n\t\tIntroduction<\/a>\n\t\t
      \n\t\t\t
    1. \n\t\t\t\tFundamental Services<\/a>\n\t\t\t<\/li>\n\t\t\t
    2. \n\t\t\t\tOther Services<\/a>\n\t\t\t<\/li>\n\t\t\t
    3. \n\t\t\t\tLoose Coupling<\/a>\n\t\t\t<\/li>\n\t\t\t
    4. \n\t\t\t\tStrong Typing Benefits<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
    5. \n\t\tCDI Beans<\/a>\n\t\t
        \n\t\t\t
      1. \n\t\t\t\tBean Attributes<\/a>\n\t\t\t<\/li>\n\t\t\t
      2. \n\t\t\t\tWhat is a Managed Bean<\/a>\n\t\t\t<\/li>\n\t\t\t
      3. \n\t\t\t\tInjectable Objects<\/a>\n\t\t\t<\/li>\n\t\t\t
      4. \n\t\t\t\tAlternatives<\/a>\n\t\t\t<\/li>\n\t\t\t
      5. \n\t\t\t\tInterceptors<\/a>\n\t\t\t<\/li>\n\t\t\t
      6. \n\t\t\t\tUsing Qualifiers<\/a>\n\t\t\t<\/li>\n\t\t\t
      7. \n\t\t\t\tUsing Qualifier with Members<\/a>\n\t\t\t<\/li>\n\t\t\t
      8. \n\t\t\t\tInjecting Beans<\/a>\n\t\t\t<\/li>\n\t\t\t
      9. \n\t\t\t\tUsing Scopes<\/a>\n\t\t\t<\/li>\n\t\t\t
      10. \n\t\t\t\tProducer Methods<\/a>\n\t\t\t<\/li>\n\t\t\t
      11. \n\t\t\t\tObtain Bean Programmatically<\/a>\n\t\t\t<\/li>\n\t\t\t
      12. \n\t\t\t\tInjectionPoint object<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
      13. \n\t\tConfigure CDI App<\/a>\n\t<\/li>\n\t
      14. \n\t\tReferences<\/a>\n\t<\/li>\n<\/ol>\n<\/ol>\n<\/div>\n
         <\/div>\n

        Introduction<\/h2><\/span>\n

        Fundamental Services<\/h3><\/span>\n

        * Contexts
        \n– Bind stateful components to lifecycle contexts (i.e. client does not control bean’s lifecycle, container does)
        \n– Lifecycle contexts are well defined and extensible
        \n* Dependency injection
        \n– Inject components into an application in a typesafe<\/strong> way
        \n– Deployment time decision on which implementation of a particular interface to inject<\/p>\n

        Other Services<\/h3><\/span>\n

        * EL (expression language) integration:
        \n– Components can be used directly on JSP\/JSF pages
        \n* Decorate injected components
        \n* Associate interceptors with components using typesafe interceptor bindings
        \n* Event notification model
        \n* Added web conversation scope (in addition to request, session, and application)
        \n* Complete SPI spec:
        \n– Clean third party integration<\/p>\n

        Loose Coupling<\/h3><\/span>\n

        * Server\/client decoupling via
        \n– Well-defined types and qualifiers (so that server implementation may vary)
        \n* Component lifecycle decoupling via
        \n– Adding context to components
        \n– Automatic life cycle management for components
        \n– Allowing stateful components to interact like services (purely by message passing)
        \n* Message producer\/consumer decoupling via events
        \n* Orthogonal concerns decoupling via JEE interceptors<\/p>\n

        Strong Typing Benefits<\/h3><\/span>\n

        * No lookups using string-based names for wiring and correlations (errors can be detected at compile time)
        \n* Allow Java annotation<\/p>\n

        CDI Beans<\/h2><\/span>\n

        * Beans are stateful whose lifecycles are managed by containers, not by bean clients.<\/p>\n

        Bean Attributes<\/h3><\/span>\n

        * Bean Types
        \n– Almost any Java type may be a bean type
        \n* Qualifiers
        \n* Scope
        \n* EL name
        \n* Interceptor bindings
        \n* Implementation<\/p>\n

        What is a Managed Bean<\/h3><\/span>\n

        A managed bean is a top-level Java class if
        \n* Defined to be a managed bean by, for example, JSF spec.
        \n* Or meets all the following conditions:
        \n– It is not a nonstatic inner class
        \n– It is a concrete class or is annotated @Decorator
        \n– It is not annotated with an EJB component-defining annotation or declared as an EJB bean class in ejb-jar.xml
        \n– It has an appropriate constructor:
        \n1) a constructor with no parameters
        \n2) a constructor annotated @Inject<\/p>\n

        Injectable Objects<\/h3><\/span>\n

        * Any Java class (almost: what’s not?)
        \n* Session Beans
        \n* JEE resources: data sources, JMS topics\/queues\/connection factories
        \n* Persistence contexts (JPA EntityManager objects)
        \n* Producer fields
        \n* Objects returned by producer methods
        \n* Web service references
        \n* Remote EJB references<\/p>\n

        Alternatives<\/h3><\/span>\n

        * Annotate a bean implementation as Alternative<\/p>\n

        \r\npublic @Alternative\r\nclass MockPaymentProcessor extends PaymentProcessorImpl { ... }\r\n<\/pre>\n
        * Specify to use alternative implementation in beans.xml<\/p>\n
        \r\n\r\n\r\n   \r\n         org.mycompany.mock.MockPaymentProcessor<\/class>\r\n   <\/alternatives>\r\n\r\n<\/beans>\r\n<\/pre>\n
        Interceptors<\/h3><\/span>\n
        * An interceptor binding type is a user-defined annotation that is itself annotated @InterceptorBinding<\/strong>.
        \n* It lets us bind interceptor classes to bean classes with no <\/strong>direct dependency between the two classes.
        \n* Interceptors are disabled by default. Use beans.xml to enable interceptor and order interceptors.
        \n* Define an interceptor binding type:<\/p>\n
        \r\n@InterceptorBinding\r\n@Inherited\r\n@Target( { TYPE, METHOD })\r\n@Retention(RUNTIME)\r\npublic @interface Transactional {}\r\n<\/pre>\n
        * Implement the interceptor binding type:<\/p>\n
        \r\npublic @Transactional @Interceptor\r\nclass TransactionInterceptor { ... }\r\n<\/pre>\n
        * Apply the interceptor to a bean:<\/p>\n
        \r\npublic @SessionScoped @Transactional\r\nclass ShoppingCart implements Serializable { ... }\r\n<\/pre>\n
        Using Qualifiers<\/h3><\/span>\n
        * A qualifier is an annotation that you apply to a bean
        \n* A qualifier type is a Java annotation defined as
        \n@Target({METHOD, FIELD, PARAMETER, TYPE})
        \n@Retention(RUNTIME)
        \n* Used to provide various implementations of a particular bean type.
        \n* All non qualifier annotated class are automatically annotated with @Default
        \n* Example:<\/p>\n
        \r\npackage greetings;\r\nimport static java.lang.annotation.ElementType.*;\r\nimport static java.lang.annotation.RetentionPolicy.RUNTIME;\r\n\r\nimport java.lang.annotation.*;\r\nimport javax.inject.Qualifier;\r\n\r\n@Qualifier\r\n@Retention(RUNTIME)\r\n@Target({TYPE, METHOD, FIELD, PARAMETER})\r\npublic @interface Informal {}\r\n<\/pre>\n
        * Use the new Qualifier:<\/p>\n
        \r\npackage greetings;\r\n@Informal\r\npublic class InformalGreeting extends Greeting {\r\npublic String greet(String name) {\r\nreturn \"Hi, \" + name + \"!\";\r\n}\r\n}\r\n<\/pre>\n
        Using Qualifier with Members<\/h3><\/span>\n
        * Define a qualifier with member, e.g. TestUser <\/strong>:<\/p>\n
        \r\n@Qualifier\r\n@Retention(RUNTIME)\r\n@Target({ TYPE, METHOD, FIELD, PARAMETER })\r\npublic @interface TestUser {\r\n\tUserId userId() default UserId.user1;\t\r\n}\r\n<\/pre>\n
        * Use UserId<\/strong> enum class to define available user ids:<\/p>\n
        \r\npublic enum UserId {\r\n\tuser1,\r\n\tuser2;\r\n}\r\n<\/pre>\n
        * User Provider class to produce test User<\/em> instances:<\/p>\n
        \r\npublic class TestUserProvider {\r\n\r\n\t@Produces @TestUser(userId=UserId.user1)\r\n\tpublic User getUser1(){\r\n                User user = new User(\"user1\");\r\n                return user;\r\n        }\r\n\r\n\t@Produces @TestUser(userId=UserId.user2)\r\n\tpublic User getUser1(){\r\n                User user = new User(\"user2\");\r\n                return user;\r\n        }\r\n<\/pre>\n
        * Inject User<\/me> instance in classes:<\/p>\n
        \r\n\t@Inject\r\n\t@TestUser(userId = UserId.user1)\r\n\tUser user;\r\n<\/pre>\n
        Injecting Beans<\/h3><\/span>\n
        * Inject a @Default Greeting object:<\/p>\n
        \r\nimport javax.inject.Inject; \r\npublic class Printer { \r\n  @Inject Greeting greeting; \r\n  ...\r\n}\r\n<\/pre>\n
        * Inject a @Informal Greeting object:<\/p>\n
        \r\nimport javax.inject.Inject; \r\npublic class Printer { \r\n  @Inject @Informal Greeting greeting; \r\n  ...\r\n}\r\n<\/pre>\n
        Using Scopes<\/h3><\/span>\n
        * CDI introduces two additional scopes, i.e. Dependent and Conversion:<\/p>\n
        \r\n@RequestScoped\r\n@SessionScoped\r\n@ApplicationScoped\r\n@Dependent\r\n@ConversationScoped\r\n<\/pre>\n
        * Example:<\/p>\n
        \r\nimport javax.inject.Inject; \r\nimport javax.enterprise.context.RequestScoped;\r\nimport javax.inject.Named;\r\n\r\n@Named(\"printer\")\r\n@RequestScoped\r\npublic class Printer { \r\n  @Inject @Informal Greeting greeting; \r\n  ...\r\n}\r\n<\/pre>\n
        Producer Methods<\/h3><\/span>\n
        * Producer methods provide a way to inject <\/strong>objects that
        \n– are not beans (e.g. a number)
        \n– whose values may vary at runtime
        \n– that require custom initialization (let application take full control of bean instantiation process)
        \n* Example:
        \n– Define producer method:<\/p>\n
        \r\nprivate int maxNumber = 100;\r\n...\r\n@Produces @MaxNumber int getMaxNumber() {\r\n  return maxNumber;\r\n}\r\n<\/pre>\n
        – Inject in another managed bean will initialize maxNumber to 100:<\/p>\n
        \r\n@Inject @MaxNumber private int maxNumber;\r\n<\/pre>\n
        Obtain Bean Programmatically<\/h3><\/span>\n
        * Get a bean factory:<\/p>\n
        \r\n@Inject Instance paymentProcessorSource;\r\n<\/pre>\n
        * Get a bean factory using qualifier:<\/p>\n
        \r\n@Inject @Asynchronous Instance paymentProcessorSource;\r\n<\/pre>\n
        * Get the bean<\/p>\n
        \r\nPaymentProcessor p = paymentProcessorSource.get();\r\n<\/pre>\n
        InjectionPoint object<\/h3><\/span>\n
        * Used to access metadata relating to the injection point to which it belongs
        \n* Example
        \n– Declare a LogFactory class to produce a Logger object with appropriate class name:<\/p>\n
        \r\npublic class LogFactory implements Serializable {\r\n\r\n\tprivate static final long serialVersionUID = 5266112323136335431L;\r\n\r\n\t@Produces\r\n\tLogger createLogger(InjectionPoint injectionPoint) {\r\n\t\tString name = injectionPoint.getMember().getDeclaringClass()\r\n\t\t\t\t.getName();\r\n\t\tLogger log = Logger.getLogger(name);\r\n\r\n\t\treturn log;\r\n\t}\r\n\r\n}\r\n<\/pre>\n
        – Use following in code to automatically obtain class name:<\/p>\n
        \r\n@Inject Logger log;\r\n<\/pre>\n
        – Above is equivalent to:<\/p>\n
        \r\nLogger log = Logger.getLogger(MyClass.class.getName());\r\n<\/pre>\n
        – For example,<\/p>\n
        \r\nimport mil.osd.dmdc.diss.test.util.WeldJUnit4Runner;\r\n\r\nimport org.apache.log4j.Logger;\r\nimport org.junit.Test;\r\nimport org.junit.runner.RunWith;\r\n\r\n@RunWith(WeldJUnit4Runner.class)\r\npublic class TestLogger {\r\n\t@Inject\r\n\tLogger log;\r\n\t\r\n         \/\/ Note that TestLogger2 has to be injected.\r\n         \/\/ In another word this won't work: TestLogger2 l2 = new TestLogger2(); l2.testLog(); \r\n\t@Inject\r\n\tTestLogger2 l2;\r\n\t\r\n\t@Test\r\n\tpublic void testLogger() {\r\n\t\tlog.debug(\"Test logger...\");\r\n\t}\r\n\t\r\n\t@Test\r\n\tpublic void testLogger2() {\r\n\t\tl2.testLog();\r\n\t}\r\n}\r\n<\/pre>\n
        \r\nimport javax.inject.Inject;\r\nimport org.apache.log4j.Logger;\r\n\r\npublic class TestLogger2 {\r\n\t@Inject\tLogger log;\r\n\r\n\tpublic void testLog(){\r\n\t\tlog.debug(\"TestLogger2...\");\r\n\t}\r\n}\r\n<\/pre>\n
        Configure CDI App<\/h2><\/span>\n
        * Must have beans.xml<\/em> in
        \n– META-INF (EJB modules or JAR files)
        \n– or WEB-INF (web app): avoid this.
        \n– or WEB-INF\/classes\/META-INF (web app)<\/p>\n
        References<\/h2><\/span>\n
        * The Java EE 6 Tutorial: Basic Concepts, Fourth Edition By: Eric Jendrock et al Chapter 17
        \n* Weld – JSR-299 Reference Implementation<\/a>
        \n*         To inject or not to inject: CDI is the question<\/a>
        \n*         Dependency Injection – An Introductory Tutorial – Part 1<\/a> <\/p>\n","protected":false},"excerpt":{"rendered":"
        Introduction Fundamental Services * Contexts – Bind stateful components to lifecycle contexts (i.e. client does not control bean’s lifecycle, container does) – Lifecycle contexts are well defined and extensible * Dependency injection – Inject components into an application in a … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[120],"tags":[],"class_list":["post-3849","post","type-post","status-publish","format-standard","hentry","category-jsf"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p8cRUO-105","_links":{"self":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/3849","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3849"}],"version-history":[{"count":18,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/3849\/revisions"}],"predecessor-version":[{"id":4371,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/3849\/revisions\/4371"}],"wp:attachment":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3849"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3849"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3849"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}