Movatterモバイル変換

Resource Injection

Thejavax.annotation.Resource annotation is used to declare a reference to a resource.@Resourcecan decorate a class, a field, or a method. The container will injectthe resource referred to by@Resource into the component either at runtime or whenthe component is initialized, depending on whether field/method injection or class injection isused. With field and method-based injection, the container will inject the resource whenthe application is initialized. For class-based injection, the resource is looked up bythe application at runtime.

@Resource has the following elements:

name: The JNDI name of the resource
type: The Java language type of the resource
authenticationType: The authentication type to use for the resource
shareable: Indicates whether the resource can be shared
mappedName: A non-portable, implementation-specific name to which the resource should be mapped
description: The description of the resource

Thename element is the JNDI name of the resource, and is optionalfor field- and method-based injection. For field-based injection, the defaultname is thefield name qualified by the class name. For method-based injection, the defaultnameis the JavaBeans property name based on the method qualified by the classname. Thename element must be specified for class-based injection.

The type of resource is determined by one of the following:

The type of the field the@Resource annotation is decorating for field-based injection
The type of the JavaBeans property the@Resource annotation is decorating for method-based injection
Thetype element of@Resource

For class-based injection, thetype element is required.

TheauthenticationType element is used only for connection factory resources, and can beset to one of thejavax.annotation.Resource.AuthenticationType enumerated type values:CONTAINER, the default, andAPPLICATION.

Theshareable element is used only for ORB instance resources or connection factoryresource. It indicates whether the resource can be shared between this component andother components, and may be set totrue, the default, orfalse.

ThemappedName element is a non-portable, implementation-specific name that the resource should bemapped to. Because thename element, when specified or defaulted, is local onlyto the application, many Java EE servers provide a way of referring toresources across the application server. This is done by setting themappedName element.Use of themappedName element is non-portable across Java EE server implementations.

Thedescription element is the description of the resource, typically in the defaultlanguage of the system on which the application is deployed. It is usedto help identify resources, and to help application developers choose the correct resource.

Field-Based Injection

To use field-based resource injection, declare a field and decorate it with the@Resource annotation. The container will infer the name and type of the resourceif thename andtype elements are not specified. If you dospecify the type element, it must match the field’s type declaration.

package com.example;public class SomeClass {    @Resource    private javax.sql.DataSource myDB;...}

In the code above, the container infers thename of the resource basedon the class name and the field name:com.example.SomeClass/myDB. The inferredtypeisjavax.sql.DataSource.class.

package com.example;public class SomeClass {    @Resource(name="customerDB")    private javax.sql.DataSource myDB;...}

In the code above, the JNDI name iscustomerDB, and the inferredtypeisjavax.sql.DataSource.class.

Method-Based Injection

To use method-based injection, declare a setter method and decorate it with the@Resource annotation. The container will infer the name and type of the resourceif thename andtype elements are not specified. The setter methodmust follow the JavaBeans conventions for property names: the method name must beginwithset, have avoid return type, and only one parameter. If youdo specify thetype element, it must match the field’s type declaration.

package com.example;public class SomeClass {    private javax.sql.DataSource myDB;...    @Resource    private void setMyDB(javax.sql.DataSource ds) {        myDB = ds;    }...}

In the code above, the container infers thename of the resource basedon the class name and the field name:com.example.SomeClass/myDB. The inferredtypeisjavax.sql.DataSource.class.

package com.example;public class SomeClass {    private javax.sql.DataSource myDB;...    @Resource(name="customerDB")    private void setMyDB(javax.sql.DataSource ds) {        myDB = ds;    }...}

In the code above, the JNDI name iscustomerDB, and the inferredtypeisjavax.sql.DataSource.class.

Class-Based Injection

To use class-based injection, decorate the class with a@Resource annotation, andset the requiredname andtype elements.

@Resource(name="myMessageQueue",                type="javax.jms.ConnectionFactory")public class SomeMessageBean {...}

Declaring Multiple Resources

The@Resources annotation is used to group together multiple@Resource declarations for class-basedinjection.

@Resources({    @Resource(name="myMessageQueue",                    type="javax.jms.ConnectionFactory"),    @Resource(name="myMailSession",                    type="javax.mail.Session")})public class SomeMessageBean {...}

The code above shows the@Resources annotation containing two@Resource declarations. One isa JMS message queue, and the other is a JavaMail session.