Java BundleWiring類代碼示例

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
@Override
public byte[] processClass(String className, byte[] bytes, ClasspathEntry ce, BundleEntry be, ClasspathManager cm) {
    final BaseData bd = ce.getBaseData();
    if (bd == null) {
        return bytes;
    }
    final Bundle b = bd.getBundle();
    if (b == null) {
        return bytes;
    }
    BundleWiring w = b.adapt(org.osgi.framework.wiring.BundleWiring.class);
    if (w == null) {
        return bytes;
    }
    ClassLoader loader = w.getClassLoader();
    return archive.patchByteCode(loader, className, ce.getDomain(), bytes);
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
/**
 * Checks if is required bundle.
 *
 * @param bundle the bundle
 * @param className the class name
 * @return true, if is required bundle
 */
private boolean isRequiredBundle(Bundle bundle, String className) {
	
	// --- 1. Simply try to load the class ----------------------
	try {
		Class<?> classInstance = bundle.loadClass(className);
		if (classInstance!=null)  return true;
	
	} catch (ClassNotFoundException cnfEx) {
		//cnfEx.printStackTrace();
	}
	
	// --- 2. Try to check the resources of the bundle ----------
	String simpleClassName = className.substring(className.lastIndexOf(".")+1);
	String packagePath = className.substring(0, className.lastIndexOf("."));
	packagePath = packagePath.replace(".", "/");
	if (packagePath.startsWith("/")==false) packagePath = "/" + packagePath;
	if (packagePath.endsWith("/")  ==false) packagePath = packagePath + "/";
	
	BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
	Collection<String> resources = bundleWiring.listResources(packagePath, simpleClassName + ".class", BundleWiring.LISTRESOURCES_LOCAL);
	if (resources!=null && resources.size()>0) {
		return true;
	}
	return false;
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
private boolean incompatibleExtender(Bundle bundle) {
   	
	List<BundleWire> requiredWires = bundle.adapt(BundleWiring.class)
			.getRequiredWires(OSGI_EXTENDER_NS);
	
	for(BundleWire bw : requiredWires) {
		BundleCapability capability = bw.getCapability();
		if(EntityManagerFactoryBuilder.JPA_CAPABILITY_NAME.equals(
				capability.getAttributes().get(OSGI_EXTENDER_NS))) {
			
			// If the persistence bundle requires a different revision for the 
			// JPA extender then we are incompatible, otherwise we are
			return !capability.getRevision().equals(wiring.getRevision());
		}
	}
	
	// If there is no requirement then we must assume that it's safe
	return false;
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
public WrappingTransformer(ClassTransformer delegate, ServiceReference<?> persistenceProvider) {
    validate(delegate, persistenceProvider);
    this.delegate = delegate;

    Object packages = persistenceProvider.getProperty("org.apache.aries.jpa.container.weaving.packages");
    if (packages instanceof String[]) {
        for (String s : (String[])packages) {
            packageImportsToAdd.add(s);
        }
    } else {
        Bundle provider = persistenceProvider.getBundle();
        String suffix = ";" + Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE + "=" + provider.getSymbolicName()
                        + ";" + Constants.BUNDLE_VERSION_ATTRIBUTE + "=" + provider.getVersion();

        BundleRevision br = provider.adapt(BundleWiring.class).getRevision();
        for (BundleCapability bc : br.getDeclaredCapabilities(BundleRevision.PACKAGE_NAMESPACE)) {
            packageImportsToAdd.add(bc.getAttributes().get(BundleRevision.PACKAGE_NAMESPACE) + suffix);
        }
    }
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
@Override
public void weave(WovenClass wovenClass) {
    BundleWiring wiring = wovenClass.getBundleWiring();
    Bundle bundle = wiring.getBundle();
    ClassLoader cl = wiring.getClassLoader();
    Collection<ClassTransformer> transformersToTry = getTransformers(bundle);
    for (ClassTransformer transformer : transformersToTry) {
        if (transformClass(wovenClass, cl, transformer)) {
            LOGGER.info("Weaving " + wovenClass.getClassName() + " using " + transformer.getClass().getName());
            break;
        }
    }
    Class<?> dClass = wovenClass.getDefinedClass();
    if (transformersToTry.isEmpty() && dClass != null && dClass.getAnnotation(Entity.class) != null) {
        LOGGER.warn("Loading " + wovenClass.getClassName() + " before transformer is present");
    }
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
/**
 * Get all the relevant packages that the EclipseLink JPA provider exports or persistence packages it uses itself. These are needed
 * so that the woven proxy (for runtime enhancement) can be used later on :)
 * 
 * Note that differently to OpenJPA the relevant classes are actually in more than just one bundle (org.eclipse.persistence.jpa and org.eclipse.persistence.core
 * at the time of this writing). Hence, we have to take more than just the packages of the JPA provider bundle into account ...
 * 
 * @param jpaBundle
 * @return
 */
private String[] getJPAPackages(Bundle jpaBundle) {
    Set<String> result = new HashSet<String>();

    for (Bundle b : context.getBundles()) {
        BundleWiring bw = b.adapt(BundleWiring.class);
        if (bw == null) {
            continue;
        }
        boolean isJpaBundle = b.equals(jpaBundle);
        List<BundleWire> wires = bw.getProvidedWires(BundleRevision.PACKAGE_NAMESPACE);
        for (BundleWire w : wires) {
            String pkgName = (String)w.getCapability().getAttributes().get(BundleRevision.PACKAGE_NAMESPACE);
            boolean add = isJpaBundle || pkgName.startsWith("org.eclipse.persistence");
            if (add) {
                result.add(getPkg(b, pkgName));
            }
        }
    }
    
    result.add(getPkg(context.getBundle(), "org.apache.aries.jpa.eclipselink.adapter.platform"));
    LOG.debug("Found JPA packages {}", result);
    return result.toArray(new String[0]);
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
<T> List<Class<? extends T>> findSubTypesOf(Bundle bundle, Collection<Class<T>> superclasses) {
    BundleWiring wiring = bundle.adapt(BundleWiring.class);
    Collection<String> names = wiring
            .listResources("/", "*", BundleWiring.LISTRESOURCES_RECURSE);
    return names.stream().map(new Function<String, Class<?>>() {
        @Override @SneakyThrows
        public Class<?> apply(String name) {
            String n = name.replaceAll("\\.class$", "").replace('/', '.');
            try {
                return bundle.loadClass(n);
            } catch (ClassNotFoundException | NoClassDefFoundError e) {
                return null;
            }
        }
    }).filter(c -> c != null)
                .filter(c -> superclasses.stream().anyMatch(sc -> sc.isAssignableFrom(c)))
                .filter(c -> c.isAnnotationPresent(GraphQLMutation.class))
                .filter(c -> !c.isInterface() && !Modifier.isAbstract(c.getModifiers()))
                .map((Function<Class<?>, Class<? extends T>>) aClass -> (Class<? extends T>) aClass)
                .collect(Collectors.toList());
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
static Set<String> getClassNames(Bundle bundle) {
    BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
    if (bundleWiring == null)
        return Collections.emptySet();
    Collection<String> resources = bundleWiring.listResources("/", "*.class", BundleWiring.LISTRESOURCES_RECURSE);
    Set<String> classNamesOfCurrentBundle = new HashSet<>();
    for (String resource : resources) {
        URL localResource = bundle.getEntry(resource);
        // Bundle.getEntry() returns null if the resource is not located in the specific bundle
        if (localResource != null) {
            String className = resource.replaceAll("/", ".").replaceAll("^(.*?)(\\.class)$", "$1");
            classNamesOfCurrentBundle.add(className);
        }
    }

    return classNamesOfCurrentBundle;
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
private <T> List<Class<? extends T>> findSubTypesOf(Bundle bundle, Collection<Class<T>> superclasses) {
    BundleWiring wiring = bundle.adapt(BundleWiring.class);
    Collection<String> names = wiring
            .listResources("/", "*", BundleWiring.LISTRESOURCES_RECURSE);
    return names.stream().map(new Function<String, Class<?>>() {
        @Override @SneakyThrows
        public Class<?> apply(String name) {
            String n = name.replaceAll("\\.class$", "").replace('/', '.');
            try {
                return bundle.loadClass(n);
            } catch (ClassNotFoundException | NoClassDefFoundError e) {
                return null;
            }
        }
    }).filter(c -> c != null).filter(c -> superclasses.stream().anyMatch(sc -> sc.isAssignableFrom(c)))
                .filter(c -> !c.isInterface() && !Modifier.isAbstract(c.getModifiers()))
                .map((Function<Class<?>, Class<? extends T>>) aClass -> (Class<? extends T>) aClass)
                .collect(Collectors.toList());
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
@SuppressWarnings({
 "rawtypes"
})
public void testGetService() throws ClassNotFoundException {
    final Object myTestProxyObject = new Object();

    IMocksControl control = EasyMock.createControl();
    EndpointDescription endpoint = createTestEndpointDesc();
    ImportRegistrationImpl iri = new ImportRegistrationImpl(endpoint, null);

    BundleContext consumerContext = control.createMock(BundleContext.class);
    Bundle consumerBundle = control.createMock(Bundle.class);
    BundleWiring bundleWiring = control.createMock(BundleWiring.class);
    EasyMock.expect(bundleWiring.getClassLoader()).andReturn(this.getClass().getClassLoader());
    EasyMock.expect(consumerBundle.adapt(BundleWiring.class)).andReturn(bundleWiring);
    EasyMock.expect(consumerBundle.getBundleContext()).andReturn(consumerContext);
    ServiceRegistration sreg = control.createMock(ServiceRegistration.class);


    DistributionProvider handler = mockDistributionProvider(myTestProxyObject);
    control.replay();

    ClientServiceFactory csf = new ClientServiceFactory(endpoint, handler, iri);
    assertSame(myTestProxyObject, csf.getService(consumerBundle, sreg));
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
@Override
public BundleClasses getBundleClasses(ComponentSpecification bundleSpec, Set<String> packagesToScan) {
    //Not written in an OO way since FelixFramework resides in JDisc core which for now is pure java,
    //and to load from classpath one needs classes from scalalib.

    //Temporary hack: Using class name since ClassLoaderOsgiFramework is not available at compile time in this bundle.
    if (osgiFramework.getClass().getName().equals("com.yahoo.application.container.impl.ClassLoaderOsgiFramework")) {
        Bundle syntheticClassPathBundle = first(osgiFramework.bundles());
        ClassLoader classLoader = syntheticClassPathBundle.adapt(BundleWiring.class).getClassLoader();

        return new BundleClasses(
                syntheticClassPathBundle,
                OsgiUtil.getClassEntriesForBundleUsingProjectClassPathMappings(classLoader, bundleSpec, packagesToScan));
    } else {
        Bundle bundle = getBundle(bundleSpec);
        if (bundle == null)
            throw new RuntimeException("No bundle matching " + quote(bundleSpec));

        return new BundleClasses(bundle, OsgiUtil.getClassEntriesInBundleClassPath(bundle, packagesToScan));
    }
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
public LayerFactoryImpl(Activator activator, BundleContext context, Module systemModule) {
	String layerTypeProp = context.getProperty("osgi.jpms.layer.type");
	this.layerType = layerTypeProp == null ? LayerType.OneBundlePerLayerWithHierarchy : LayerType.valueOf(layerTypeProp);
	this.activator = activator;
	this.context = context;
	this.systemModule = systemModule;
	long startTime = System.nanoTime();
	privatesCache = loadPrivatesCache(context, activator);
	System.out.println("Time loadPrivatesCache: " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - startTime), TimeUnit.NANOSECONDS));
	Bundle systemBundle = context.getBundle(Constants.SYSTEM_BUNDLE_LOCATION);
	fwkWiring = systemBundle.adapt(FrameworkWiring.class);
	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	layersWrite = lock.writeLock();
	layersRead = lock.readLock();

	BundleWiring systemWiring = systemBundle.adapt(BundleWiring.class);
	addToResolutionGraph(Collections.singleton(systemWiring));
	wiringToModule.put(systemWiring, systemModule);
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
private Set<BundleWiring> getInUseBundleWirings() {
	Set<BundleWiring> wirings = new HashSet<>();
	Collection<BundleCapability> bundles = fwkWiring.findProviders(ALL_BUNDLES_REQUIREMENT);
	for (BundleCapability bundleCap : bundles) {
		// Only pay attention to non JPMS boot modules.
		// NOTE this means we will not create a real JPMS Module or Layer for this bundle
		if (bundleCap.getAttributes().get(BOOT_JPMS_MODULE) == null) {
			BundleRevision revision = bundleCap.getRevision();
			BundleWiring wiring = revision.getWiring();
			if (wiring != null && wiring.isInUse()) {
				wirings.add(wiring);
			}
			if (revision.getBundle().getBundleId() == 0) {
				// also store the system.bundle fragments because they may have exports unknown to JPMS
				List<BundleWire> hostWires = wiring.getProvidedWires(HostNamespace.HOST_NAMESPACE);
				for (BundleWire hostWire : hostWires) {
					wirings.add(hostWire.getRequirerWiring());
				}
			}
		}
	}
	return wirings;
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
private void addReadsNest(Map<BundleWiring, Module> wiringToModule) {
	long addReadsNestStart = System.nanoTime();
	Set<Module> bootModules = ModuleLayer.boot().modules();
	Collection<Module> allBundleModules = wiringToModule.values();
	// Not checking for existing edges for simplicity.
	for (Module module : allBundleModules) {
		if (!systemModule.equals(module)) {
			// First add reads to all boot modules.
			addReads(module, bootModules);
			// Now ensure bidirectional read of all bundle modules.
			addReads(module, allBundleModules);
			// Add read to the system.bundle module.
			addReads(module, Collections.singleton(systemModule));
		}
	}
	System.out.println("Time to addReadsNest: " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - addReadsNestStart), TimeUnit.NANOSECONDS));
}
 

import org.osgi.framework.wiring.BundleWiring; //導入依賴的package包/類
private void addToResolutionGraph(Set<BundleWiring> currentWirings) {
	long startAddToGraph = System.nanoTime();
	currentWirings.forEach((w) -> addToGraph(w));
	System.out.println("Time addToGraph: " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - startAddToGraph), TimeUnit.NANOSECONDS));

	long startAddWires = System.nanoTime();
	for (Iterator<ResolutionGraph.Node> nodes = graph.iterator(); nodes.hasNext();) {
		ResolutionGraph.Node n = nodes.next();
		if (!currentWirings.contains(n.getValue()) && n.getValue().getBundle().getBundleId() != 0) {
			nodes.remove();
		} else {
			addWires(n);
		}
	}
	System.out.println("Time addWires: " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - startAddWires), TimeUnit.NANOSECONDS));

	long startPopulateSources = System.nanoTime();
	graph.populateSources();
	System.out.println("Time populateSources: " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - startPopulateSources), TimeUnit.NANOSECONDS));
}