/*
* Copyright 2006-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.osgi.service.importer.support;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Filter;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.osgi.context.BundleContextAware;
import org.springframework.osgi.service.exporter.OsgiServicePropertiesResolver;
import org.springframework.osgi.service.importer.OsgiServiceLifecycleListener;
import org.springframework.osgi.util.OsgiFilterUtils;
import org.springframework.osgi.util.internal.ClassUtils;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
/**
* Base class for importing OSGi services. Provides the common properties and
* contracts between importers.
*
* @author Costin Leau
* @author Adrian Colyer
* @author Hal Hildebrand
*/
public abstract class AbstractOsgiServiceImportFactoryBean implements FactoryBean, InitializingBean, DisposableBean,
BundleContextAware, BeanClassLoaderAware, BeanNameAware {
private static final Log log = LogFactory.getLog(AbstractOsgiServiceImportFactoryBean.class);
/** context classloader */
private ClassLoader classLoader;
private BundleContext bundleContext;
private ImportContextClassLoader contextClassLoader = ImportContextClassLoader.CLIENT;
// not required to be an interface, but usually should be...
private Class[] interfaces;
// filter used to narrow service matches, may be null
private String filter;
// Cumulated filter string between the specified classes/interfaces and the
// given filter
private Filter unifiedFilter;
// service lifecycle listener
private OsgiServiceLifecycleListener[] listeners;
/** Service Bean property of the OSGi service * */
private String serviceBeanName;
private Cardinality cardinality;
/** bean name */
private String beanName = "";
public void afterPropertiesSet() {
Assert.notNull(this.bundleContext, "Required 'bundleContext' property was not set.");
Assert.notNull(classLoader, "Required 'classLoader' property was not set.");
Assert.notNull(interfaces, "Required 'interfaces' property was not set.");
// validate specified classes
Assert.isTrue(!ClassUtils.containsUnrelatedClasses(interfaces),
"more then one concrete class specified; cannot create proxy.");
this.listeners = (listeners == null ? new OsgiServiceLifecycleListener[0] : listeners);
getUnifiedFilter(); // eager initialization of the cache to catch filter
// errors
Assert.notNull(interfaces, "Required serviceTypes property not specified.");
}
/**
* Assembles the configuration properties into one unified OSGi filter. Note
* that this implementation creates the filter on the first call and caches
* it afterwards.
*
* @return unified filter based on this factory bean configuration
*/
public Filter getUnifiedFilter() {
if (unifiedFilter != null) {
return unifiedFilter;
}
String filterWithClasses = OsgiFilterUtils.unifyFilter(interfaces, filter);
boolean trace = log.isTraceEnabled();
if (trace)
log.trace("Unified classes=" + ObjectUtils.nullSafeToString(interfaces) + " and filter=[" + filter
+ "] in=[" + filterWithClasses + "]");
// add the serviceBeanName constraint
String filterWithServiceBeanName = OsgiFilterUtils.unifyFilter(
OsgiServicePropertiesResolver.BEAN_NAME_PROPERTY_KEY, new String[] { serviceBeanName }, filterWithClasses);
if (trace)
log.trace("Unified serviceBeanName [" + ObjectUtils.nullSafeToString(serviceBeanName) + "] and filter=["
+ filterWithClasses + "] in=[" + filterWithServiceBeanName + "]");
// create (which implies validation) the actual filter
unifiedFilter = OsgiFilterUtils.createFilter(filterWithServiceBeanName);
return unifiedFilter;
}
/**
* Sets the classes that the imported service advertises.
*
* @param interfaces array of advertised classes.
*/
public void setInterfaces(Class[] interfaces) {
this.interfaces = interfaces;
}
/**
* Sets the thread context class loader management strategy to use for
* services imported by this service. By default
* {@link ImportContextClassLoader#CLIENT} is used.
*
* @param contextClassLoader import context class loader management strategy
* @see ImportContextClassLoader
*/
public void setContextClassLoader(ImportContextClassLoader contextClassLoader) {
Assert.notNull(contextClassLoader);
this.contextClassLoader = contextClassLoader;
}
public void setBundleContext(BundleContext context) {
this.bundleContext = context;
}
/**
* Sets the OSGi service filter. The filter will be concatenated with the
* rest of the configuration properties specified (such as interfaces) so
* there is no need to include them in the filter.
*
* @param filter OSGi filter describing the importing OSGi service
*/
public void setFilter(String filter) {
this.filter = filter;
}
/**
* Sets the lifecycle listeners interested in receiving events for this
* importer.
*
* @param listeners importer listeners
*/
public void setListeners(OsgiServiceLifecycleListener[] listeners) {
this.listeners = listeners;
}
/**
* Sets the OSGi service bean name. This setting should be normally used
* when the imported service has been exported by Spring DM exporter. You
* may specify additional filtering criteria if needed (using the filter
* property) but this is not required.
*
* @param serviceBeanName importer service bean name
*/
public void setServiceBeanName(String serviceBeanName) {
this.serviceBeanName = serviceBeanName;
}
/**
* {@inheritDoc}
*
* This method is called automatically by the container.
*/
public void setBeanClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
/**
* Returns the class loader used by this FactoryBean.
*
* @return factory bean class loader
*/
public ClassLoader getBeanClassLoader() {
return classLoader;
}
/**
* Returns the bundleContext used by this FactoryBean.
*
* @return factory bean class loader
*/
public BundleContext getBundleContext() {
return bundleContext;
}
/**
* Returns the interfaces used for discovering the imported service(s).
*
* @return interfaces advertised by services in the OSGi space
*/
public Class[] getInterfaces() {
return interfaces;
}
/**
* Returns the filter describing the imported service(s).
*
* @return filter describing the imported service(s)
*/
public String getFilter() {
return filter;
}
/**
* Returns the listeners interested in receiving events for this importer.
*
* @return lifecycle listeners used by this importer
*/
public OsgiServiceLifecycleListener[] getListeners() {
return listeners;
}
/**
* Returns the context class loader management strategy.
*
* @return the context class loader management strategy
*/
public ImportContextClassLoader getContextClassLoader() {
return contextClassLoader;
}
/**
* Returns the cardinality used by this importer.
*
* @return importer cardinality
*/
public Cardinality getCardinality() {
return cardinality;
}
/**
* Sets the importer cardinality (0..1, 1..1, 0..N, or 1..N). Default is
* 1..X.
*
* @param cardinality importer cardinality.
*/
public void setCardinality(Cardinality cardinality) {
Assert.notNull(cardinality);
this.cardinality = cardinality;
}
/**
* Returns the bean name associated with the instance of this class (when
* running inside the Spring container).
*
* @return component bean name
*/
public String getBeanName() {
return beanName;
}
public void setBeanName(String name) {
beanName = name;
}
}
|