JSR-330和assertion(断言)介绍

Injectable fields:

  - are annotated with @Inject.
  - are not final.
  - may have any otherwise valid name.

@Inject FieldModifiers(opt) Type VariableDeclarators;

Injectable methods:
- are annotated with @Inject.
- are not abstract.
- do not declare type parameters of their own.
- may return a result
- may have any otherwise valid name.
- accept zero or more dependencies as arguments.


@Inject MethodModifiers(opt) ResultType Identifier(FormalParameterList(opt)) Throws(opt) MethodBody

@Inject
WeatherDao weatherDao;

@Inject
WeatherDao(Context context) {
    this.context = context;
}

public class Car {
     @Inject @Named("driver") Seat driverSeat;
     @Inject @Named("passenger") Seat passengerSeat;
     ...
}

Identifies qualifier annotations. Anyone can define a new qualifier. A qualifier annotation:

- is annotated with @Qualifier, @Retention(RUNTIME), and typically @Documented.
- can have attributes.
- may be part of the public API, much like the dependency type, but unlike implementation types which needn't be part of the public API.
- may have restricted usage if annotated with @Target. While this specification covers applying qualifiers to fields and parameters only, some injector configurations might use qualifier annotations in other places (on methods or classes for example).

@Qualifier
@Documented
@Retention(value=RUNTIME)
public @interface Named

@Documented  
@Retention(RetentionPolicy.RUNTIME)  
@Qualifier  
@Target(value = {ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})  
public @interface Genre {  
    User user() default User.STUDENT;  
    public enum User {STUDENT, TEACHER}  
}

@Named  
@Genre(user = User.STUDENT)  
public class StudentDAO implements IUserDAO{  
    @Override  
    public int count() {  
        System.out.println("----StudentDAO----");  
        return 0;
    }
}

Provides instances of T. Typically implemented by an injector. For any type T that can be injected, you can also inject Provider<T>. Compared to injecting T directly, injecting Provider<T> enables:

- retrieving multiple instances.
- lazy or optional retrieval of an instance.
- breaking circular dependencies.
- abstracting scope so you can look up an instance in a smaller scope from an instance in a containing scope.

class Car {
@Inject Car(Provider<Seat> seatProvider) {
   Seat driver = seatProvider.get();
   Seat passenger = seatProvider.get();
   ...
 }
}

T	get()
    Provides a fully-constructed and injected instance of T.

@Scope
@Documented
@Retention(value=RUNTIME)
public @interface Singleton
Identifies a type that the injector only instantiates once. Not inherited.

@Singleton
class Log {
   void log(String message) { ... }
}

1.assert expression1;

2.assert expression1: expression2;