Java 类javax.inject.Inject 实例源码

@Inject
public RateLimitedExecutor(Config config) {

    // Check arguments.
    checkNotNull(config, "config");

    // Set class fields.
    this.executorService = createExecutorService(config.getThreadCount());
    this.rateLimiter = RateLimiter.create(
            config.getMaxRequestCountPerSecond(),
            config.getRampUpDurationSeconds(),
            TimeUnit.SECONDS);
    LOGGER.debug(
            "instantiated (threadCount={}, maxRequestCountPerSecond={}, rampUpDurationSeconds={})",
            config.getThreadCount(), config.getMaxRequestCountPerSecond(), config.getRampUpDurationSeconds());

}

@Inject
public void setPluginService(PluginService pluginService)
{
    ownerHandlers = new PluginTracker<SecurityTargetHandler>(pluginService, "com.tle.core.security",
        "securityTargetHandler", "handlesOwnershipFor");
    ownerHandlers.setBeanKey("handler");

    labellingHandlers = new PluginTracker<SecurityTargetHandler>(pluginService, "com.tle.core.security",
        "securityTargetHandler", "handlesLabellingFor");
    labellingHandlers.setBeanKey("handler");

    transformHandlers = new PluginTracker<SecurityTargetHandler>(pluginService, "com.tle.core.security",
        "securityTargetHandler", "handlesTransformationOf");
    transformHandlers.setBeanKey("handler");

    postProcessors = new PluginTracker<SecurityPostProcessor>(pluginService, "com.tle.core.security", "securityPostProcessor",
        null).setBeanKey("bean");
}

@Inject ServerTagger(Server server) {
    this.tags = Lazy.from(() -> {
        final TagSetBuilder builder = new TagSetBuilder();
        builder
            .add("server", server.slug())
            .add("datacenter", server.datacenter())
            .add("box", server.box())
            .add("network", server.network().name().toLowerCase())
            .add("role", server.role().name().toLowerCase())
            .add("visibility", server.visibility().name().toLowerCase())
            .add("family", server.family())
            .addAll("realm", server.realms());

        if(server.game_id() != null) {
            builder.add("game", server.game_id());
        }

        return builder.build();
    });
}

@Inject
public AnimationEditorComponent(MenuBarComponent menuBar, AnimationEditorPresenter presenter, TimelineEditorComponent timelineEditor,
                                PropertyEditorComponent propertyEditor, SceneComponent scene, PlayerComponent player, PropertyStore propertyStore,
                                SaveDialogComponent saveDialogComponent, EventBus eventBus) {

    this.menuBar = menuBar;
    this.timelineEditor = timelineEditor;
    this.propertyEditor = propertyEditor;
    this.scene = scene;
    this.player = player;
    this.propertyStore = propertyStore;
    this.saveDialogComponent = saveDialogComponent;
    initUi();
    initPresenter(presenter);
    configureDividerPosition();
    subscribeToEvents(eventBus);
}

/**
 * Create an instance of a {@link SimpleBookmarkStore}.
 * <p>
 * If it observed that the {@link org.dnacronym.hygene.parser.GfaFile} in {@link GraphStore} has changed, it will
 * clear all current {@link SimpleBookmark}s and load the {@link Bookmark}s associated with the new
 * {@link org.dnacronym.hygene.parser.GfaFile}.
 * <p>
 * It uses the {@link GraphDimensionsCalculator} as a reference for each internal {@link SimpleBookmark}.
 *
 * @param graphStore                the {@link GraphStore} to be observed by this class
 * @param graphVisualizer           the {@link GraphVisualizer} to be used by this class
 * @param graphDimensionsCalculator the {@link GraphDimensionsCalculator} to be used by this class
 * @param sequenceVisualizer        the {@link SequenceVisualizer} to be used by this class
 * @see SimpleBookmark
 */
@Inject
public SimpleBookmarkStore(final GraphStore graphStore, final GraphVisualizer graphVisualizer,
                           final GraphDimensionsCalculator graphDimensionsCalculator,
                           final SequenceVisualizer sequenceVisualizer) {
    this.graphDimensionsCalculator = graphDimensionsCalculator;
    this.graphVisualizer = graphVisualizer;
    this.sequenceVisualizer = sequenceVisualizer;

    simpleBookmarks = new ArrayList<>();
    observableSimpleBookmarks = FXCollections.observableList(simpleBookmarks);
    observableSimpleBookmarks.addListener((ListChangeListener<SimpleBookmark>) listener -> graphVisualizer.draw());

    graphStore.getGfaFileProperty().addListener((observable, oldValue, newValue) -> {
        try {
            fileBookmarks = new FileBookmarks(new FileDatabase(newValue.getFileName()));

            simpleBookmarks.clear();
            addBookmarks(fileBookmarks.getAll());
        } catch (final SQLException | IOException e) {
            LOGGER.error("Unable to load bookmarks from file.", e);
        }
    });
}

@Inject
public WifiMeasurementsGatherer(SensorConfig sensorConfig,
                                WifiManager wifiManager,
                                @Named("wifiSensorEnableRequester")SensorEnableRequester sensorEnableRequester,
                                @Named("fineLocationPermissionChecker") PermissionChecker permissionChecker,
                                @Named("wifiSensorChecker")SensorChecker sensorChecker,
                                SensorRequirementChecker sensorRequirementChecker,
                                Context context){
    super(sensorConfig, sensorEnableRequester, permissionChecker, sensorChecker, sensorRequirementChecker);
    this.wifiManager = wifiManager;
    this.context = context;
}

@Inject
public MessageBufferConfiguration(Config config) {
    if (config.hasPath("message-buffer-size")) {
        this.size = config.getInt("message-buffer-size");
    } else {
        this.size = SIZE;
    }
}

@Inject
GeraltWomanPhotosPresenter(final RxLoaderManager loaderManager,
                           final GeraltWomanPhotoLoaderFactory loaderFactory,
                           final CommandStarter commandStarter,
                           final MessageFactory messageFactory,
                           final ResourcesManager resourcesManager,
                           @WomanId final long womanId) {
    super(loaderManager);
    this.loaderFactory = loaderFactory;
    this.commandStarter = commandStarter;
    this.messageFactory = messageFactory;
    this.resourcesManager = resourcesManager;
    this.womanId = womanId;
}

@Inject
IntroducerManager(MessageSender messageSender, ClientHelper clientHelper,
        Clock clock, CryptoComponent cryptoComponent,
        IntroductionGroupFactory introductionGroupFactory) {

    this.messageSender = messageSender;
    this.clientHelper = clientHelper;
    this.clock = clock;
    this.cryptoComponent = cryptoComponent;
    this.introductionGroupFactory = introductionGroupFactory;
}

@Inject
public DefaultPullRequestReferenceManager(Dao dao, UserManager userManager, 
        MarkdownManager markdownManager) {
    super(dao);
    this.markdownManager = markdownManager;
    this.userManager = userManager;
}

@Inject
public SplashInteractor(@ApplicationContext Context context,
                        PreferencesHelper preferencesHelper,
                        ApiHelper apiHelper) {

    super(preferencesHelper, apiHelper);
    mContext = context;
}

@Inject
ForumControllerImpl(@DatabaseExecutor Executor dbExecutor,
        LifecycleManager lifecycleManager, IdentityManager identityManager,
        @CryptoExecutor Executor cryptoExecutor,
        ForumManager forumManager, ForumSharingManager forumSharingManager,
        EventBus eventBus, Clock clock, MessageTracker messageTracker,
        AndroidNotificationManager notificationManager) {
    super(dbExecutor, lifecycleManager, identityManager, cryptoExecutor,
            eventBus, clock, notificationManager, messageTracker);
    this.forumManager = forumManager;
    this.forumSharingManager = forumSharingManager;
}

@Inject
public LoginPresenter(LoginContract.Model model, LoginContract.View rootView
        , RxErrorHandler handler, Application application
        , ImageLoader imageLoader, AppManager appManager) {
    super(model, rootView);
    this.mErrorHandler = handler;
    this.mApplication = application;
    this.mImageLoader = imageLoader;
    this.mAppManager = appManager;
}

@Inject MatchPlayerExecutor(SyncExecutor syncExecutor, Match match, UUID uuid) {
    super(syncExecutor);
    this.uuid = uuid;

    if(!match.isUnloaded()) {
        this.match = match;
        this.match.registerEvents(this);
    }
}

@Inject @Replaceable
public TomorrowWeatherViewModel(NavigationController navigation,
                                @RxObservable(PAGE) Observable<Integer> pageChangeObservable,
                                PermissionService permissionService,
                                LocationService locationService,
                                WeatherService weatherService,
                                TomorrowWeatherResponseFilter weatherParser,
                                @RxScheduler(MAIN) Scheduler androidScheduler) {
    super(navigation, pageChangeObservable, permissionService, locationService, weatherService, weatherParser, androidScheduler);
}

/**
 * Constructor.
 * @param mapper mapper
 * @param attribuutConverteerder attributen converteerder
 * @param historieNabewerking historie nabewerking
 */
@Inject
protected ReisdocumentStandaardMutatieVerwerker(
        final ReisdocumentMapper mapper,
        final BrpAttribuutConverteerder attribuutConverteerder,
        final PersoonReisdocumentHistorieNabewerking historieNabewerking) {
    super(mapper, new ReisdocumentConverteerder(attribuutConverteerder), attribuutConverteerder, historieNabewerking, ReisdocumentMapper.GROEP_ELEMENT,
            LOGGER);
}

/**
 * @param pool connection to Redis
 */
@Inject
public RedisKeyRepository(final JedisPool pool) {
    if (pool == null) {
        throw new IllegalArgumentException("pool cannot be null");
    }
    this.pool = pool;
}

@Inject
CalculatorPresenterImpl(CalculateOperationsInteractor interactorCalculateOperations,
                        CharactersValidator validator,
                        StringTransformator transformator,
                        ParseInputInteractor interactorParseInput) {
    this.interactorCalculations = interactorCalculateOperations;
    this.interactorParseInput = interactorParseInput;
    this.validator = validator;
    this.transformator = transformator;
}

@Inject
public DatabaseInputConfiguration(@Assisted String id,
                                  @Assisted Config config,
                                  DatabaseInput.Factory inputFactory) {
    super(id, config);
    this.inputFactory = inputFactory;
    if (config.hasPath("db-driver")) {
        this.dbDriver = config.getString("db-driver");
    }
    if (config.hasPath("db-connection-url")) {
        this.dbConnectionUrl = config.getString("db-connection-url");
    }
    if (config.hasPath("sql")) {
        this.sql = config.getString("sql");
    }
    if (config.hasPath("key-type")) {
        this.keytype = config.getString("key-type");
    }
    if (config.hasPath("id-field")) {
        this.idfield = config.getString("id-field");
    }
    if (config.hasPath("db-driver-path")) {
        this.dbDriverPath = config.getString("db-driver-path");
    }
    if (config.hasPath("init-sql")) {
        this.initSql = config.getString("init-sql");
    }
    if (config.hasPath("db-user")) {
        this.dbUser = config.getString("db-user");
    }
    if (config.hasPath("db-password")) {
        this.dbPassword = config.getString("db-password");
    }
    if (config.hasPath("db-sync-time")) {
        this.dbSyncTime = config.getInt("db-sync-time");
    } else {
        this.dbSyncTime = 1;
    }
}

@Inject
public AddMachineRouter(ServiceResponse serviceResponse,
                        AddMachineService service, EndpointProtector protector) {
    super(serviceResponse);
    this.service = service;
    this.protector = protector;
}

@Inject
public SubscriberConsumer(
    LeadService lead,
    Serializer serializer,
    Committer committer,
    TransactionsBuffer buffer,
    DoneNotifier doneNotifier,
    FullCommitHandler fullCommitHandler,
    DeserializerClosure deserializerClosure,
    BufferOverflowCondition bufferOverflowCondition,
    KafkaFactory kafkaFactory,
    DataRecoveryConfig dataRecoveryConfig,
    @Named(DataCapturerBusConfiguration.NODE_ID) UUID consumerId,
    OnKafkaStop onKafkaStop
) {
    this.lead = lead;
    this.serializer = serializer;
    this.committer = committer;
    this.buffer = buffer;
    this.doneNotifier = doneNotifier.setBuffer(buffer);
    this.fullCommitHandler = fullCommitHandler.setBuffer(buffer);
    this.deserializerClosure = deserializerClosure.setBuffer(buffer);
    this.bufferOverflowCondition = bufferOverflowCondition;
    consumer = kafkaFactory.consumer(dataRecoveryConfig.getConsumerConfig(), onKafkaStop);

    this.consumerId = consumerId;
    remoteTopic = dataRecoveryConfig.getRemoteTopic();
    reconciliationTopic = dataRecoveryConfig.getReconciliationTopic();
}

@Inject MatchExecutor(SyncExecutor executor, Match match) {
    super(executor);

    if(!match.isUnloaded()) {
        this.match = match;
        this.match.registerEvents(this);
    }
}

@Inject DynamicScheduler(Match match, FeatureDefinitionContext fdc) {
    this.match = match;

    // Process dynamics in lexical order
    final Comparator<Dynamic> order = Comparator.comparing(Dynamic::getDefinition, fdc);
    this.clearQueue = new PriorityQueue<>(order);
    this.placeQueue = new PriorityQueue<>(order);
}

@Inject
public FeedViewModel(UserManager userManager, FeedRepo repo, UserRestService userRestService) {
    super(userManager);
    this.userRestService = userRestService;
    this.feedRepo = repo;
    refresh(300);
}

@Inject
public Maneuvers(MpDbf mpDbf, MnDbf mnDbf) {
    Map<Long, List<ManeuverPath>> mpById = mpDbf.paths().stream().sorted(Comparator.comparing(ManeuverPath::getSeqnr)).collect(groupingBy(ManeuverPath::getId));
    for (Maneuver maneuver : mnDbf.maneuvers()) {
        List<ManeuverPath> path = mpById.get(maneuver.getId());
        List<Long> segments = path.stream().map(ManeuverPath::getTrpelId).collect(toList());
        checkState(segments.size() > 1);
        restrictionRoadIds.addAll(segments);
        restrictions.add(new Restriction(segments, maneuver.getJunctionId()));
    }
    log.info("{} maneuvers found", restrictions.size());
}

@Inject
public MoveContentOperationExecutor(@Assisted("courseId") String courseId,
    @Assisted("locationId") String locationId)
{
    this.courseId = courseId;
    this.locationId = locationId;
}

@Inject
public CEIDGCaptchaMachineLearningRunner(MultiLayerConfigurationFactory multiLayerConfigurationFactory,
                                         MachineLearningService machineLearningService,
                                         MultiLayerNetworkFactory multiLayerNetworkFactory,
                                         MultiLayerNetworkSaver multiLayerNetworkSaver) {
    this.multiLayerConfigurationFactory = multiLayerConfigurationFactory;
    this.machineLearningService = machineLearningService;
    this.multiLayerNetworkFactory = multiLayerNetworkFactory;
    this.multiLayerNetworkSaver = multiLayerNetworkSaver;
}

@Inject
public VertxSubscriptionManager(
    Vertx vertx, DatasetDao datasetDao, Reader reader, AsOfFactory asOfFactory) {
  this.vertx = vertx;
  this.datasetDao = datasetDao;
  this.reader = reader;
  this.asOfFactory = asOfFactory;
  this.subscriptions = new ConcurrentHashMap<>();
  this.executor = vertx.createSharedWorkerExecutor("subscription-manager");
}

@Inject
public void setPluginService(PluginService pluginService)
{
    downloadLink = new PluginTracker<ItemUrlExtender>(pluginService,
        "com.tle.web.viewitem.treeviewer", "downloadLink", "id");
    downloadLink.setBeanKey("class");
}

@Inject
public CountriesResource(
        ConfigEntityDataRepository<CountriesConfigEntityData> countriesConfigEntityDataRepository,
        ExceptionFactory exceptionFactory
) {
    this.countriesConfigEntityDataRepository = countriesConfigEntityDataRepository;
    this.exceptionFactory = exceptionFactory;
}

@Inject
public RepositoryFactoryImpl(Instance<SurveyRepository> surveyRepository,
                             Instance<UserRepository> userRepository,
                             Instance<ResponseRepository> responseRepository) {
    this.surveyRepository = surveyRepository;
    this.userRepository = userRepository;
    this.responseRepository = responseRepository;
}

static void mockInjects(Object instance) throws Exception {
    for (Field f : instance.getClass().getDeclaredFields()) {
        Inject injected = f.getAnnotation(Inject.class);
        if (injected != null) {
            Class<?> t = f.getType();
            f.set(instance, mock(t));
        }
    }
}

@Inject
public SystemShutdownHook(final LifecycleShutdownManager shutdownManager) {
  Runtime.getRuntime().addShutdownHook(new Thread() {
    @Override
    public void run() {
      shutdownManager.shutdown();
    }
  });
}

@Inject MapLogger(@Assisted MapDefinition map, MapdevLogger mapdevLogger) {
    super(mapdevLogger.getName() + "." + map.getDottedPath(), null);
    this.map = map;
    setParent(mapdevLogger);
    setUseParentHandlers(true);
}

@Inject //通过注解进行初始化
public ImageLoader(BaseImageLoaderStrategy strategy) {
    setLoadImgStrategy(strategy);
}

@Inject
public SurveyOverviewServiceImpl(RepositoryFactory repositoryFactory, SecurityAdapter securityAdapter) {
    this.repositoryFactory = repositoryFactory;
    this.securityAdapter = securityAdapter;
}

@Inject
public KafkaConfig(@Named("kafka.host") String host, @Named("kafka.port") Integer port) {
    this.host = host;
    this.port = port;
}

@Inject
public PluginManagerInternal getPluginManager() {
    throw new UnsupportedOperationException();
}

@Inject
AddMenuBalancePresenter2(IAddMenuBalanceView view, MenuBalanceRepository2 mMenuBalanceRepository) {
    this.mView = view;
    this.mMenuBalanceRepository = mMenuBalanceRepository;
}

@Inject
public Bitflyer4jImpl(Injector i) {

    injector = i;

    environment = injector.getInstance(Environment.class);

    marketService = injector.getInstance(MarketService.class);

    accountService = injector.getInstance(AccountService.class);

    orderService = injector.getInstance(OrderService.class);

    realtimeService = injector.getInstance(RealtimeService.class);

    log.info("Initialized : {} - {}", getVersion(), getSite());

}