Java BundleContext.getService方法代码示例

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    log.info("######################################################");
    log.info("start");
    log.info("######################################################");

    Hashtable<String, String> props = new Hashtable<>();
    props.put("osgi.http.whiteboard.servlet.pattern", "/*");
    props.put("init.message", "Crazy filter!");
    props.put("service.ranking", "1");
    serviceRegistration = context.registerService(Filter.class.getName(), new CrazyFilter(), props);

    final ServiceReference<?> httpRef = context.getServiceReference("org.osgi.service.http.HttpService");
    httpService = (HttpService) context.getService(httpRef);

    httpService.registerServlet("/foo", new FooServlet(), new Hashtable(), httpService.createDefaultHttpContext());
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    randomNumberServiceTracker = new ServiceTracker<>(context, RandomNumberGenerator.class.getName(), null);
    randomNumberServiceTracker.open();
    serviceReference = randomNumberServiceTracker.getServiceReference();
    if (serviceReference != null) {
        final RandomNumberGenerator service = context.getService(serviceReference);
        if (service != null) {
            log.info("############ tracked random: {} with service {}", service.generateNumber(), service);
        } else {
            log.info("############# no tracked random because service is null");
        }
    } else {
        log.info("############# no tracked random because serviceReference is null");
    }

}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
@SuppressWarnings("IllegalCatch")
public FeaturesService addingService(final ServiceReference<FeaturesService> reference) {
    BundleContext bc = reference.getBundle().getBundleContext();
    final FeaturesService featureService = bc.getService(reference);
    final Optional<XmlFileStorageAdapter> currentPersister = XmlFileStorageAdapter.getInstance();

    if (XmlFileStorageAdapter.getInstance().isPresent()) {
        final Set<String> installedFeatureIds = Sets.newHashSet();
        try {
            for (final Feature installedFeature : featureService.listInstalledFeatures()) {
                installedFeatureIds.add(installedFeature.getId());
            }
        } catch (final Exception e) {
            LOG.error("Error listing installed features", e);
        }

        currentPersister.get().setFeaturesService(() -> installedFeatureIds);
    }
    ConfigFeaturesListener configFeaturesListener = new ConfigFeaturesListener(configPusher, featureService);
    registration = bc.registerService(FeaturesListener.class.getCanonicalName(), configFeaturesListener, null);
    return featureService;
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
protected void emit(
	ServiceReference<NestedCollectionRouter> serviceReference,
	Emitter<String> emitter) {

	Bundle bundle = FrameworkUtil.getBundle(
		NestedCollectionRouterManagerImpl.class);

	BundleContext bundleContext = bundle.getBundleContext();

	CustomServiceReferenceMapper<NestedCollectionRouter>
		customServiceReferenceMapper = new CustomServiceReferenceMapper<>(
			bundleContext, NestedCollectionRouter.class);

	NestedCollectionRouter nestedCollectionRouter =
		bundleContext.getService(serviceReference);

	Class<?> genericClass = getGenericClassFromPropertyOrElse(
		serviceReference, PARENT_MODEL_CLASS,
		() -> getTypeParamOrFail(
			nestedCollectionRouter, NestedCollectionRouter.class, 1));

	customServiceReferenceMapper.map(
		serviceReference,
		key -> emitter.emit(key + "-" + genericClass.getName()));
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Activate
public void activate(BundleContext bundleContext) {
	Application application = bundleContext.getService(_serviceReference);

	Dictionary<String, Object> properties = new Hashtable<>();

	String[] propertyKeys = _serviceReference.getPropertyKeys();

	for (String key : propertyKeys) {
		Object value = _serviceReference.getProperty(key);

		properties.put(key, value);
	}

	properties.put("osgi.jaxrs.application.base", "/");
	properties.put("osgi.jaxrs.name", ".default");

	_serviceRegistration = bundleContext.registerService(
		Application.class, application, properties);
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
/**
 * Constructs a new <code>PermissionManager</code> instance.
 * 
 * @param bc
 */
private PermissionManager(BundleContext bc) {
	ServiceReference ref = bc.getServiceReference(PermissionAdmin.class.getName());
	if (ref != null) {
		logger.trace("Found permission admin " + ref);
		pa = (PermissionAdmin) bc.getService(ref);
		bc.addBundleListener(this);
		logger.trace("Default permissions are " + ObjectUtils.nullSafeToString(pa.getDefaultPermissions()));
		logger.warn("Security turned ON");

	}
	else {
		logger.warn("Security turned OFF");
		pa = null;
	}
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
/**
 * Determines through reflection the methods used for invoking the TestRunnerService.
 *
 * @throws Exception
 */
private void initializeServiceRunnerInvocationMethods() throws Exception {
    // get JUnit test service reference
    // this is a loose reference - update it if the JUnitTestActivator class is changed.

    BundleContext ctx = getRuntimeBundleContext();

    ServiceReference reference = ctx.getServiceReference(ACTIVATOR_REFERENCE);
    Assert.notNull(reference, "no OSGi service reference found at " + ACTIVATOR_REFERENCE);

    service = ctx.getService(reference);
    Assert.notNull(service, "no service found for reference: " + reference);

    serviceTrigger = service.getClass().getDeclaredMethod("executeTest", new Class[0]);
    ReflectionUtils.makeAccessible(serviceTrigger);
    Assert.notNull(serviceTrigger, "no executeTest() method found on: " + service.getClass());
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
  public void dispose() {
super.dispose();
BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
ServiceReference<IDebugService> serviceReference = (ServiceReference<IDebugService>) bundleContext.getServiceReference(IDebugService.class.getName());
if(serviceReference != null){
	IDebugService debugService = (IDebugService)bundleContext.getService(serviceReference);
	debugService.deleteDebugFiles();
}
Properties properties = ConfigFileReader.INSTANCE.getCommonConfigurations();
try {
	killPortProcess(properties);
} catch (IOException e) {
	logger.debug("Socket is not closed.");
}
  }
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
/**
 * Returns the reference to the implementation of the specified service.
 *
 * @param serviceClass service class
 * @param <T>          type of service
 * @return service implementation
 */
public static <T> T getService(Class<T> serviceClass) {
    BundleContext bc = FrameworkUtil.getBundle(serviceClass).getBundleContext();
    if (bc != null) {
        ServiceReference<T> reference = bc.getServiceReference(serviceClass);
        if (reference != null) {
            T impl = bc.getService(reference);
            if (impl != null) {
                return impl;
            }
        }
    }
    throw new ServiceNotFoundException("Service " + serviceClass.getName() + " not found");
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    randomNumberServiceTracker = new ServiceTracker<>(context, RandomNumberGenerator.class.getName(), new ServiceTrackerCustomizer<RandomNumberGenerator, RandomNumberGenerator>() {
        @Override
        public RandomNumberGenerator addingService(ServiceReference<RandomNumberGenerator> reference) {
            log.info(">>>>>>>>>>>> customizer#addingService");
            setServiceReference(reference);
            RandomNumberGenerator service = context.getService(reference);
            consumeService(service);
            return service;
        }

        @Override
        public void modifiedService(ServiceReference<RandomNumberGenerator> reference, RandomNumberGenerator service) {
            log.info(">>>>>>>>>>>> customizer#modifiedService");
            unsetServiceReference(context);
        }

        @Override
        public void removedService(ServiceReference<RandomNumberGenerator> reference, RandomNumberGenerator service) {
            log.info(">>>>>>>>>>>> customizer#removedService");
            unsetServiceReference(context);
        }
    });
    randomNumberServiceTracker.open();

    final ServiceReference<RandomNumberGenerator> reference = randomNumberServiceTracker.getServiceReference();
    if (reference != null) {
        consumeService(context.getService(reference));
    }

}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
/**
 * Creates a {@code ServiceTracker} that will register its managed services
 * as the classes provided in the {@code classes} parameter.
 *
 * @param  bundleContext the bundle context
 * @param  clazz the managed class
 * @param  classes the list of classes with which the service will be
 *         registered
 * @param  biConsumer function that can be used to alter the properties
 *         dictionary
 * @return the service tracker
 * @review
 */
public static <T> ServiceTracker<T, ServiceRegistration<?>>
	createServiceTracker(
		BundleContext bundleContext, Class<T> clazz, String[] classes,
		BiConsumer<Dictionary<String, Object>, T> biConsumer) {

	return new ServiceTracker<>(
		bundleContext, clazz,
		(ServiceRegistrationServiceTrackerCustomizer<T>)
			serviceReference -> {
				Dictionary<String, Object> properties = getProperties(
					serviceReference);

				T t = null;

				try {
					t = bundleContext.getService(serviceReference);
				}
				catch (Exception e) {
					return null;
				}

				biConsumer.accept(properties, t);

				return bundleContext.registerService(
					classes, t, properties);
			});
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
public void testSAXParserAvailable() throws Exception {
    Framework f = IntegrationTest.findFramework();
    BundleContext bc = f.getBundleContext();
    
    ServiceReference sr = bc.getServiceReference(SAXParserFactory.class.getName());
    assertNotNull("SAX Service found", sr);
    Object srvc = bc.getService(sr);
    assertTrue("Instance of the right type: " + srvc, srvc instanceof SAXParserFactory);
        
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Object addingService(ServiceReference reference) {
    String unitName = (String)reference.getProperty(JPA_UNIT_NAME);
    if (unitName == null) {
        return null;
    }
    BundleContext puContext = reference.getBundle().getBundleContext();
    TrackedEmf tracked = new TrackedEmf();
    tracked.emf = (EntityManagerFactory)puContext.getService(reference);
    tracked.emSupplier = new EMSupplierImpl(unitName, tracked.emf, coordinator);
    tracked.emSupplierReg = puContext.registerService(EmSupplier.class, tracked.emSupplier,
                                                     getEmSupplierProps(unitName));

    EntityManager emProxy = createProxy(tracked.emSupplier);
    tracked.emProxyReg = puContext.registerService(EntityManager.class, emProxy,
                                                     getEmSupplierProps(unitName));
    
    if (getTransactionType(tracked.emf) == PersistenceUnitTransactionType.RESOURCE_LOCAL) {
        JpaTemplate txManager = new ResourceLocalJpaTemplate(tracked.emSupplier, coordinator);
        tracked.rlTxManagerReg = puContext.registerService(JpaTemplate.class, txManager,
                                                      rlTxManProps(unitName));
    } else {
        tracked.tmTracker = new TMTracker(puContext, tracked.emSupplier, unitName, coordinator);
        tracked.tmTracker.open();
    }
    return tracked;
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
@Override
protected TransactionManager acquireTransactionManager() throws Exception {
    BundleContext ctx = FrameworkUtil.getBundle(OSGiTSWrapper.class).getBundleContext();
    
    if (ctx != null) {
        ServiceReference ref = ctx.getServiceReference(TransactionManager.class.getName());
        
        if (ref != null) {
            return (TransactionManager) ctx.getService(ref);
        }            
    }
    
    return super.acquireTransactionManager();
}
 

import org.osgi.framework.BundleContext; //导入方法依赖的package包/类
private void restartConfigModules(final BundleContext bundleContext, final List<Entry<String,
        ModuleIdentifier>> configModules) {
    if (configModules.isEmpty()) {
        return;
    }

    ServiceReference<ConfigSubsystemFacadeFactory> configFacadeFactoryRef = bundleContext
            .getServiceReference(ConfigSubsystemFacadeFactory.class);
    if (configFacadeFactoryRef == null) {
        LOG.debug("ConfigSubsystemFacadeFactory service reference not found");
        return;
    }

    ConfigSubsystemFacadeFactory configFacadeFactory = bundleContext.getService(configFacadeFactoryRef);
    if (configFacadeFactory == null) {
        LOG.debug("ConfigSubsystemFacadeFactory service not found");
        return;
    }

    try (ConfigSubsystemFacade configFacade = configFacadeFactory.createFacade(
            "BlueprintContainerRestartService")) {
        restartConfigModules(configModules, configFacade);
    } catch (ParserConfigurationException | DocumentedException | ValidationException
            | ConflictingVersionException e) {
        LOG.error("Error restarting config modules", e);
    } finally {
        bundleContext.ungetService(configFacadeFactoryRef);
    }

}