Spring's @Autowire can be configured such that Spring will not throw an error if no matching autowire candidates are found: @Autowire(required=false)
Is there an equivalent JSR-330 annotation? @Inject always fails if there is no matching candidate. Is there any way I can use @Inject but not have the framework fail if no matching types are found? I haven't been able to find any documentation to that extent.
You can use java.util.Optional.
If you are using Java 8 and your Spring version is 4.1 or above (see here), instead of
@Autowired(required = false)
private SomeBean someBean;
You can just use java.util.Optional class that came with Java 8. Use it like:
@Inject
private Optional<SomeBean> someBean;
This instance will never be null, and you can use it like:
if (someBean.isPresent()) {
// do your thing
}
This way you can also do constructor injection, with some beans required and some beans optional, gives great flexibility.
Note: Unfortunately Spring does not support Guava's com.google.common.base.Optional (see here), so this method will work only if you are using Java 8 (or above).
No... there is no equivalent for optional in JSR 330... if you want to use optional injection then you will have to stick with the framework specific @Autowired annotation
Instance injection is often overlooked. It adds great flexibility. Check the availability of the dependency prior to getting it. An unsatisfied get will throw an exception which is expensive. Use:
@Inject
Instance<SomeType> instance;
SomeType instantiation;
if (!instance.isUnsatisfied()) {
instantiation = instance.get();
}
You can restrict the injection candidates as normal:
@Inject
@SomeAnnotation
Instance<SomeType> instance;
It's is possible to create a optional injection point!
You need to use injection lookup as documented in http://docs.jboss.org/weld/reference/latest/en-US/html/injection.html#lookup
@Inject
Instance<Type> instance;
// In the code
try {
instance.get();
}catch (Exception e){
}
Or even all instances of a type
@Inject
Instance<List<Type>> instances
Also the get() method is lazy evaluated if you need. The default Injection evaluates at Startup time and throw an exception if no beans are found that could be injected, the bean will be injected at runtime of course, but the application will not start if this is impossible. In the documentation you will find more examples, including how to filter the instances injected and much, much more.
The AutowiredAnnotationBeanFactoryPostProcessor (Spring 3.2) contains this method to determine if a supported 'Autowire' annotation is required or not:
/**
* Determine if the annotated field or method requires its dependency.
* <p>A 'required' dependency means that autowiring should fail when no beans
* are found. Otherwise, the autowiring process will simply bypass the field
* or method when no beans are found.
* @param annotation the Autowired annotation
* @return whether the annotation indicates that a dependency is required
*/
protected boolean determineRequiredStatus(Annotation annotation) {
try {
Method method = ReflectionUtils.findMethod(annotation.annotationType(), this.requiredParameterName);
if (method == null) {
// annotations like @Inject and @Value don't have a method (attribute) named "required"
// -> default to required status
return true;
}
return (this.requiredParameterValue == (Boolean) ReflectionUtils.invokeMethod(method, annotation));
}
catch (Exception ex) {
// an exception was thrown during reflective invocation of the required attribute
// -> default to required status
return true;
}
}
In short, no, not by default.
The method name that is being looked for by default is 'required', which is not a field on the @Inject annotation, thus, method will be null and true will be returned.
You may be able to change that by subclassing this BeanPostProcessor and overriding the determineRequiredStatus(Annotation) method to return true, or rather, something 'smarter'.
Spring supports @Nullable with @Inject:
@Inject
@Nullable
void setSomeBean(SomeBean someBean)
