GrepCode: javax.enterprise.inject.Instance (.java) - Interface

Maven-Central
/
javax.enterprise / cdi-api
/
1.0

1.1.EDR1.2
1.1.EDR1.1
1.1.EDR1
1.0
1.0-SP4
1.0-SP3
1.0-SP2
1.0-SP1
1.0-CR4
1.0-CR3
1.0-CR2
1.0-CR1
/
javax.enterprise.inject.Instance
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
  /*
2
   * JBoss, Home of Professional Open Source
3
   * Copyright 2008, Red Hat Middleware LLC, and individual contributors
4
   * by the @authors tag. See the copyright.txt in the distribution for a
5
   * full listing of individual contributors.
6
   *
7
   * Licensed under the Apache License, Version 2.0 (the "License");
8
   * you may not use this file except in compliance with the License.
9
   * You may obtain a copy of the License at
10
  * http://www.apache.org/licenses/LICENSE-2.0
11
  * Unless required by applicable law or agreed to in writing, software
12
  * distributed under the License is distributed on an "AS IS" BASIS,  
13
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
  * See the License for the specific language governing permissions and
15
  * limitations under the License.
16
  */
17
 
18
 package javax.enterprise.inject;
19
 
20
 import java.lang.annotation.Annotation;
21
 
22
 import javax.enterprise.util.TypeLiteral;
23
 import javax.inject.Provider;


Allows the application to dynamically obtain instances of 
 beans with a specified combination of required type and 
 qualifiers.
In certain situations, injection is not the most convenient 
 way to obtain a contextual reference. For example, it may not 
 be used when:
the bean type or qualifiers vary dynamically at runtime, or
depending upon the deployment, there may be no bean which 
 satisfies the type and qualifiers, or
we would like to iterate over all beans of a certain type.
In these situations, an instance of the Instance may 
 be injected:
 @Inject Instance<PaymentProcessor> paymentProcessor;
 Any combination of qualifiers may be specified at the injection 
 point:
 @Inject @PayBy(CHEQUE) Instance<PaymentProcessor> chequePaymentProcessor;
 Or, the &.064;Any qualifier may 
 be used, allowing the application to specify qualifiers dynamically:
 @Inject @Any Instance<PaymentProcessor> anyPaymentProcessor;
 Finally, the &.064;New qualifier 
 may be used, allowing the application to obtain a 
 &.064;New qualified bean:
 @Inject @New(ChequePaymentProcessor.class) 
 Instance<PaymentProcessor> chequePaymentProcessor;
 For an injected Instance:
the required type is the type parameter specified at the 
 injection point, and
the required qualifiers are the qualifiers specified at 
 the injection point.
The inherited javax.inject.Provider.get() method returns a
 contextual references for the unique bean that matches the required 
 type and required qualifiers and is eligible for injection into the 
 class into which the parent Instance was injected, or throws 
 an UnsatisfiedResolutionException or
 AmbiguousResolutionException.
PaymentProcessor pp = chequePaymentProcessor.get();The inherited java.lang.Iterable.iterator() method returns
 an iterator over contextual references for beans that match the required 
 type and required qualifiers and are eligible for injection into the class
 into which the parent Instance was injected.
for (PaymentProcessor pp: anyPaymentProcessor) pp.test();
 Parameters:<T> the required bean type Author(s):Gavin King See also:javax.inject.Provider.get()java.lang.Iterable.iterator()javax.enterprise.util.AnnotationLiteraljavax.enterprise.util.TypeLiteral
105
106
107
public interface Instance<T> extends Iterable<T>, Provider<T>
108
{
   
   
Obtains a child Instance for the given additional 
 required qualifiers.
 Parameters:qualifiers the additional required qualifiers Returns:the child Instance Throws:java.lang.IllegalArgumentException if passed two instances of the 
 same qualifier type, or an instance of an annotation that is not 
 a qualifier type
119
120
   public Instance<T> select(Annotation... qualifiers); 

   
Obtains a child Instance for the given required type and 
 additional required qualifiers.
 Parameters:<U> the required typesubtype a java.lang.Class representing the required typequalifiers the additional required qualifiers Returns:the child Instance Throws:java.lang.IllegalArgumentException if passed two instances of the 
 same qualifier type, or an instance of an annotation that is not 
 a qualifier type
133
134
   public <U extends T> Instance<U> select(Class<U> subtype, Annotation... qualifiers); 
   
   
Obtains a child Instance for the given required type and 
 additional required qualifiers.
 Parameters:<U> the required typesubtype a javax.enterprise.util.TypeLiteral representing the required typequalifiers the additional required qualifiers Returns:the child Instance Throws:java.lang.IllegalArgumentException if passed two instances of the 
 same qualifier type, or an instance of an annotation that is not 
 a qualifier type
147
148
   public <U extends T> Instance<U> select(TypeLiteral<U> subtype, Annotation... qualifiers); 
   
   
Determines if there is no bean that matches the required type and 
 qualifiers and is eligible for injection into the class into which the parent 
 Instance was injected.
 Returns:true if there is no bean that matches the required type and 
 qualifiers and is eligible for injection into the class into which the parent 
 Instance was injected, or false otherwise.
158
159
   public boolean isUnsatisfied(); 
   
   
Determines if there is more than one bean that matches the required type and 
 qualifiers and is eligible for injection into the class into which the parent 
 Instance was injected.
 Returns:true if there is more than one bean that matches the required 
 type and qualifiers and is eligible for injection into the class into which the 
 parent Instance was injected, or false otherwise.
169
170
   public boolean isAmbiguous(); 
171
172
}