org.osgi.service.component.annotations.Reference Java Examples

@Reference(
        name = "org.wso2.micro.application.deployer.handler",
        service = org.wso2.micro.application.deployer.handler.AppDeploymentHandler.class,
        cardinality = ReferenceCardinality.AT_LEAST_ONE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetDataServiceCappDeployer")
protected void setDataServiceCappDeployer(AppDeploymentHandler appDeploymentHandler) {
    if (appDeploymentHandler instanceof DataSourceCappDeployer) {
        if (Objects.isNull(ctx)) {
            // save appDeploymentHandler
            appDepHandler = appDeploymentHandler;
        } else {
            registerDataServiceCappDeployer();
        }
    }
}
 

@Reference(name = "org.wso2.carbon.ndatasource",
           service = DataSourceService.class,
           cardinality = ReferenceCardinality.MANDATORY,
           policy = ReferencePolicy.DYNAMIC,
           unbind = "unsetDatasourceHandlerService")
protected void setDatasourceHandlerService(DataSourceService dataSourceService) {
    this.dataSourceService = dataSourceService;
}
 

@Reference(name = "synapse.registrations.service",
        service = SynapseRegistrationsService.class,
        cardinality = ReferenceCardinality.AT_LEAST_ONE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetSynapseRegistrationsService")
protected void setSynapseRegistrationsService(SynapseRegistrationsService registrationsService) {

    ServiceRegistration synEnvSvcRegistration = registrationsService.getSynapseEnvironmentServiceRegistration();
    try {
        if (activated && compCtx != null) {
            SynapseEnvironmentService synEnvSvc = (SynapseEnvironmentService) compCtx.getBundleContext()
                    .getService(synEnvSvcRegistration.getReference());
            createStores(synEnvSvc);
        }
    } catch (Throwable t) {
        log.fatal("Error occurred at the osgi service method", t);
    }
}
 

@Reference(name = "externalCryptoProvider",
        service = ExternalCryptoProvider.class,
        cardinality = ReferenceCardinality.MULTIPLE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetExternalCryptoProvider")
public void setExternalCryptoProvider(ExternalCryptoProvider externalCryptoProvider) {

    this.defaultCryptoService.registerExternalCryptoProvider(externalCryptoProvider);
    if (log.isDebugEnabled()) {
        log.debug(String.format("'%s' has been injected as an external crypto provider.",
                                externalCryptoProvider.getClass().getCanonicalName()));
    }
}
 

@Reference(
        name = "secret.callback.handler.service",
        service = org.wso2.carbon.securevault.SecretCallbackHandlerService.class,
        cardinality = ReferenceCardinality.MANDATORY,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetSecretCallbackHandlerService")
protected void setSecretCallbackHandlerService(
        SecretCallbackHandlerService secretCallbackHandlerService) {
    if (log.isDebugEnabled()) {
        log.debug("SecretCallbackHandlerService acquired");
    }
    DataServicesDSComponent.secretCallbackHandlerService = secretCallbackHandlerService;

}
 

@Reference(service = MetricRegistry.class, cardinality = ReferenceCardinality.MULTIPLE,
        policy = ReferencePolicy.DYNAMIC, policyOption = ReferencePolicyOption.GREEDY)
void bindMetricRegistry(MetricRegistry metricRegistry, Map<String, Object> properties) {
    
    log.info("Binding Metrics Registry...");
    
    String name = registryName(metricRegistry, properties);
    
    CopyMetricRegistryListener listener = new CopyMetricRegistryListener(this.metrics, metricRegistry, name);
    listener.start();
    childRegistries.put(metricRegistry, listener);
    log.info("Bound Metrics Registry {} ", name);
}
 

@Reference(name = "config.context.service",
        service = Axis2ConfigurationContextService.class,
        cardinality = ReferenceCardinality.MANDATORY,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetConfigurationContext")
protected void setConfigurationContext(Axis2ConfigurationContextService configCtx) {
    DataHolder.getInstance().setConfigCtx(configCtx.getServerConfigContext());
}
 

@Reference(
        name = "config.context.service",
        service = Axis2ConfigurationContextService.class,
        cardinality = ReferenceCardinality.MANDATORY,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetConfigurationContextService")
protected void setConfigurationContextService(Axis2ConfigurationContextService contextService) {

    if (logger.isDebugEnabled()) {
        logger.debug("Setting Configuration Context Service [" + contextService + "]");
    }
    NtaskService.ccServiceInstance = contextService;
    updateAndCleanupObservers();
}
 

@Reference(
name = "secret.callback.handler.servicee",
service = org.wso2.carbon.securevault.SecretCallbackHandlerService.class,
cardinality = ReferenceCardinality.MANDATORY,
policy = ReferencePolicy.DYNAMIC,
unbind = "unsetSecretCallbackHandlerService")
 protected void setSecretCallbackHandlerService(
         SecretCallbackHandlerService secretCallbackHandlerService) {
 	if (log.isDebugEnabled()) {
 		log.debug("SecretCallbackHandlerService acquired");
 	}
 	DataSourceServiceComponent.secretCallbackHandlerService = secretCallbackHandlerService;
 	this.initSystemDataSources();
 	this.checkInitTenantUserDataSources();
 }
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void bindStaticInjectAnnotationProcessorFactory(final StaticInjectAnnotationProcessorFactory factory, final Map<String, Object> props) {
    synchronized (staticInjectAnnotationProcessorFactories) {
        staticInjectAnnotationProcessorFactories.bind(factory, props);
        this.adapterImplementations.setStaticInjectAnnotationProcessorFactories(staticInjectAnnotationProcessorFactories.get());
    }
}
 

/**
 * Receive an event about the creation of a SynapseEnvironment. If this is
 * SuperTenant we have to wait until all the other constraints are met and actual
 * initialization is done in the activate method. Otherwise we have to do the activation here.
 *
 * @param synapseEnvironmentService SynapseEnvironmentService which contains information
 *                                  about the new Synapse Instance
 */
@Reference(
        name = "synapse.env.service",
        service = org.wso2.micro.integrator.initializer.services.SynapseEnvironmentService.class,
        cardinality = ReferenceCardinality.AT_LEAST_ONE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetSynapseEnvironmentService")
protected void setSynapseEnvironmentService(SynapseEnvironmentService synapseEnvironmentService) {
    this.synapseEnvironmentService = synapseEnvironmentService;
    DataHolder.getInstance().setSynapseEnvironmentService(this.synapseEnvironmentService);
}
 

@Reference(
        name = "config.context.service",
        service = Axis2ConfigurationContextService.class,
        cardinality = ReferenceCardinality.MANDATORY,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetConfigurationContextService")
protected void setConfigurationContextService(Axis2ConfigurationContextService configurationContextService) {

    if (log.isDebugEnabled()) {
        log.debug("ConfigurationContextService bound to the ESB initialization process");
        log.debug("configurationContextService : " + configurationContextService);
    }
    this.configCtxSvc = configurationContextService;
    ConfigurationHolder.getInstance().setAxis2ConfigurationContextService(configurationContextService);
}
 

@Reference
protected void setMetadataRegistry(MetadataRegistry metadataRegistry) {
    if (this.metadataRegistry == null) {
        this.metadataRegistry = metadataRegistry;
        this.metadataRegistry.addRegistryChangeListener(metadataRegistryChangeListener);
    }
}
 

@Reference(
    service = CatalogIdentifier.class,
    bind = "bindCatalogIdentifier",
    unbind = "unbindCatalogIdentifier",
    cardinality = ReferenceCardinality.AT_LEAST_ONE,
    policy = ReferencePolicy.DYNAMIC)
protected void bindCatalogIdentifier(CatalogIdentifier identifier, Map<?, ?> properties) {
    map.put(identifier.getCommerceProviderName(), identifier.getAllCatalogIdentifiers());
}
 

@Reference(
    service = GraphqlDataService.class,
    bind = "bindGraphqlDataService",
    unbind = "unbindGraphqlDataService",
    cardinality = ReferenceCardinality.AT_LEAST_ONE,
    policy = ReferencePolicy.DYNAMIC)
protected void bindGraphqlDataService(GraphqlDataService client, Map<?, ?> properties) {
    String identifier = client.getIdentifier();
    LOGGER.info("Registering GraphqlDataService '{}'", identifier);
    clients.put(identifier, client);
}
 

@Reference(
    service = GraphqlClient.class,
    bind = "bindGraphqlClient",
    unbind = "unbindGraphqlClient",
    cardinality = ReferenceCardinality.MULTIPLE,
    policy = ReferencePolicy.DYNAMIC)
void bindGraphqlClient(GraphqlClient graphqlClient, Map<?, ?> properties) {
    identifiers.add(graphqlClient.getIdentifier());
}
 

@Reference
protected void setItemRegistry(ItemRegistry itemRegistry) {
    if (this.itemRegistry == null) {
        this.itemRegistry = itemRegistry;
    }
}
 

@Reference(unbind = "-")
protected void setSchedulerEngineHelper(SchedulerEngineHelper schedulerEngineHelper) {

	_schedulerEngineHelper = schedulerEngineHelper;
}
 

@Reference(unbind = "-")
protected void setTriggerFactory(TriggerFactory triggerFactory) {
	_triggerFactory = triggerFactory;
}
 

@Reference(unbind = "-")
protected void setTriggerFactory(TriggerFactory triggerFactory) {
}
 

@Reference(target = ModuleServiceLifecycle.PORTAL_INITIALIZED, unbind = "-")
protected void setModuleServiceLifecycle(ModuleServiceLifecycle moduleServiceLifecycle) {
}
 

@Reference(cardinality = ReferenceCardinality.OPTIONAL, policy = ReferencePolicy.DYNAMIC)
public void setCardRegistry(CardRegistry cardRegistry) {
    this.cardRegistry = cardRegistry;
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addSkill(Skill skill) {
    this.skills.put(skill.getIntentId(), skill);
    // reset the trainer
    this.intentTrainer = null;
}
 

@Reference(unbind = "-")
protected void setTriggerFactory(TriggerFactory triggerFactory) {
}
 

@Reference
protected void setNotificationService(NotificationService notificationService) {
    this.notificationService = notificationService;
}
 

@Reference(unbind = "-")
protected void setTriggerFactory(TriggerFactory triggerFactory) {
}
 

@Reference(policy = ReferencePolicy.DYNAMIC)
@Override
protected void setStorageService(StorageService storageService) {
    super.setStorageService(storageService);
}
 

@Reference(target = ModuleServiceLifecycle.PORTAL_INITIALIZED, unbind = "-")
protected void setModuleServiceLifecycle(ModuleServiceLifecycle moduleServiceLifecycle) {
}
 

@Reference
protected void setCardBuilder(CardBuilder cardBuilder) {
    this.cardBuilder = cardBuilder;
}
 

@Reference(target = ModuleServiceLifecycle.PORTAL_INITIALIZED, unbind = "-")
protected void setModuleServiceLifecycle(ModuleServiceLifecycle moduleServiceLifecycle) {
}