import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
/**
 *  -- IMPLEMENT FUNCTIONS
 */
public List<ServiceDependency> getComponents(DependencyManager dm){
    List<ServiceDependency> components = new ArrayList<ServiceDependency>()   ;
    components.add(dm.createServiceDependency()
                    .setService(Radar.class)
                    .setRequired(true)
            );
    components.add(dm.createServiceDependency()
                    .setService(GPS.class)
                    .setRequired(true)
            );
    components.add(dm.createServiceDependency()
                    .setService(Engine.class)
                    .setRequired(true)
            );
    components.add(dm.createServiceDependency()
                    .setService(Gun.class)
                    .setRequired(true)
            );
    return components;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
private void handleDependencies(Component component, Object service){
	Dependency annotation = service.getClass().getAnnotation(Dependency.class);
	if (annotation != null){
		ServiceDependency serviceDependency = manager.createServiceDependency();
		String filter = annotation.filter();
		if (StringUtils.isNotEmpty(filter)){
			serviceDependency.setService(annotation.serviceName(), filter);
		} else {
			serviceDependency.setService(annotation.serviceName());
		}
		serviceDependency.setRequired(annotation.mandatory());
		
		String added = StringUtils.isNotEmpty(annotation.addedCallbackMethod()) ? annotation.addedCallbackMethod() : null ;
		String changed = StringUtils.isNotEmpty(annotation.changedCallbackMethod()) ? annotation.changedCallbackMethod() : null ;
		String removed = StringUtils.isNotEmpty(annotation.removedCallbackMethod()) ? annotation.removedCallbackMethod() : null ;
		serviceDependency.setCallbacks(service, added, changed, removed);

		component.add(serviceDependency);
	}
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public void init(BundleContext bundleContext, DependencyManager dependencyManager) throws Exception {
    Tactic tactic = new SimpleTactic();


    Component component = createComponent()
                           .setInterface(Tactic.class.getName(), null)
                           .setImplementation(tactic)
                           .setCallbacks("init", "startTactic", "stopTactic", "destroy");

    for(ServiceDependency dep : tactic.getComponents(dependencyManager)) {
        component.add(dep);
    }

    component.add(
        createServiceDependency()
        .setService(ArchitectureEventController.class)
        .setRequired(true)
    );

    component.add(
        createServiceDependency()
        .setService(Subscriber.class)
        .setRequired(true)
    );

    component.add(
        createServiceDependency()
        .setService(Discoverer.class)
        .setRequired(true)
    );

    component.add(
        createServiceDependency()
        .setService(DroneInit.class)
        .setRequired(true)
    );

    dependencyManager.add(component);
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@SuppressWarnings("rawtypes") // can't change org.apache.felix.dm.ServiceDependency
@Override
public ServiceDependency setService(Class serviceName) {
    this.m_dep.setService(serviceName, "(containerName="
            + this.containerName + ")");
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
private ContainerServiceDependency(ServiceDependency explicitDependency,
        String containerName) {
    this.m_dep = explicitDependency;
    this.containerName = containerName;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setDefaultImplementation(Object implementation) {
    this.m_dep.setDefaultImplementation(implementation);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setRequired(boolean required) {
    this.m_dep.setRequired(required);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setAutoConfig(boolean autoConfig) {
    this.m_dep.setAutoConfig(autoConfig);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setCallbacks(String added, String removed) {
    this.m_dep.setCallbacks(added, removed);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setPropagate(boolean propagate) {
    this.m_dep.setPropagate(propagate);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public ServiceDependency setInstanceBound(boolean isInstanceBound) {
    this.m_dep.setInstanceBound(isInstanceBound);
    return this;
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
@Override
public Dependency createCopy() {
    return new ContainerServiceDependency((ServiceDependency) this.m_dep
            .createCopy(), this.containerName);
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
/**
 * Return a ServiceDependency customized ad hoc for slicing, this
 * essentially the same org.apache.felix.dm.ServiceDependency just
 * with some filters pre-set
 *
 * @param containerName containerName for which we want to create the dependency
 *
 * @return a ServiceDependency
 */
protected ServiceDependency createContainerServiceDependency(
        String containerName) {
    return (new ContainerServiceDependency(this.dm, containerName));
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
/**
 * Return a ServiceDependency as provided by Dependency Manager as it's
 *
 *
 * @return a ServiceDependency
 */
protected ServiceDependency createServiceDependency() {
    return this.dm.createServiceDependency();
}
 

import org.apache.felix.dm.ServiceDependency; //导入依赖的package包/类
public abstract Iterable<? extends ServiceDependency> getComponents(DependencyManager dependencyManager);