OSGi中的Java类加载器用法

Question

我对OSGi中Java ClassLoader的用法有疑问.

我写了两个OSGi包,即服务器包和客户端包.

在服务器包中,我实现了BundleActivator,如:

public class Activator implements BundleActivator {

    public void start(BundleContext context) {
        System.out.println("[Server:Activator.java:26] " + Activator.class.getClassLoader());
        context.registerService(HelloService.class, new HelloService(), null);
    }

    public void stop(BundleContext context) {
        System.out.println("Stopping the bundle");
    }
}

在客户端捆绑中,我实现了BundleActivator,如:

public class Activator implements BundleActivator {

    public void start(BundleContext context) {
        ServiceReference<HelloService> ref = context.getServiceReference(HelloService.class);
        HelloService service = context.getService(ref);
        System.out.println("[Client:Activator.java:48] " + HelloService.class.getClassLoader());
        System.out.println("[Client:Activator.java:49] " + Activator.class.getClassLoader());
    }

    public void stop(BundleContext context) {
        System.out.println("Stopping the bundle");
    }
}

当我启动OSGi时,控制台输出:

[服务器:Activator.java:26] org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader@56b161a [osgi-server:1.0.0(id = 54)] [客户端:Activator.java:48] org.eclipse.osgi .internal.baseadaptor.DefaultClassLoader @ 56b161a [osgi-server:1.0.0(id = 54)] [Client:Activator.java:49] org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader@3a1b72aa [osgi-client:1.0 0.0(ID = 55)]

如您所见,无论是在服务器端还是客户端,加载HelloService的类加载器始终为DefaultClassLoader @ 56b161a.

我不明白这.据我所知,当在类A中引用类B时,类B的类加载器与类A的类加载器相同.但在OSGi中,似乎不是这样.

你能开导我吗？有没有我想念的Java ClassLoader？或OSGi做了一些棘手的事情？

服务器包的MANIFEST是:

Manifest-Version: 1.0
Bnd-LastModified: 1452582379580
Build-Jdk: 1.7.0_45
Built-By: haoruan
Bundle-Activator: com.cisco.ruan.server.Activator
Bundle-Description: osgi-server OSGi bundle project.
Bundle-ManifestVersion: 2
Bundle-Name: osgi-server Bundle
Bundle-SymbolicName: osgi-server
Bundle-Version: 1.0
Created-By: Apache Maven Bundle Plugin
Export-Package: com.cisco.ruan.server;version="1.0";uses:="org.osgi.fram
 ework"
Import-Package: org.osgi.framework;version="[1.7,2)"
Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.5))"
Tool: Bnd-3.0.0.201509101326

客户端包的MANIFEST是:

Manifest-Version: 1.0
Bnd-LastModified: 1452582396099
Build-Jdk: 1.7.0_45
Built-By: haoruan
Bundle-Activator: com.cisco.ruan.client.Activator
Bundle-Description: osgi-client OSGi bundle project.
Bundle-ManifestVersion: 2
Bundle-Name: osgi-client Bundle
Bundle-SymbolicName: osgi-client
Bundle-Version: 1.0
Created-By: Apache Maven Bundle Plugin
Export-Package: com.cisco.ruan.client;version="1.0";uses:="com.cisco.rua
 n.server,org.osgi.framework"
Import-Package: com.cisco.ruan.server;version="[1.0,2)",org.osgi.framewo
 rk;version="[1.7,2)",org.slf4j;version="[1.7,2)"
Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.5))"
Tool: Bnd-3.0.0.201509101326

================================================== ====

嗨,尼尔,这是我刚才做的实验:

我有ClassA和ClassB,而类Wrapper指的是这两个类.

public class Wrapper {

    public Wrapper() {
        showInfo();
    }

    public void showInfo() {
        System.out.println("[Wrapper.java:5] " + ClassA.class.getClassLoader());
        System.out.println("[Wrapper.java:8] " + ClassB.class.getClassLoader());
    }
}

我编写了自己的自定义类加载器MyClassLoader:

class MyClassLoader extends ClassLoader {
    private ClassLoader haocl;
    private ClassLoader ruancl;

    public MyClassLoader() {
        this.haocl = new HaoClassLoader();
        this.ruancl = new RuanClassLoader();
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {

        if (name.endsWith("com.cisco.ruan.classloader.ClassA")) {
            return haocl.loadClass(name);
        }

        if (name.endsWith("com.cisco.ruan.classloader.ClassB")) {
            return ruancl.loadClass(name);
        }

        if (name.endsWith("Wrapper")) {
            InputStream is = null;
            try {
                is = new FileInputStream("/Users/haoruan/Desktop/Projects/cl-test/target/classes/com/cisco/ruan/classloader/Wrapper.class");
            } catch (Exception e) {
                e.printStackTrace();
            }
            byte[] bytes = null;
            try {
                bytes = ByteStreams.toByteArray(is);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return defineClass(name, bytes, 0, bytes.length);
        }

        return super.loadClass(name);

    }
}

然后我打电话Class.forName("com.cisco.ruan.classloader.Wrapper", true, mcl).newInstance();,控制台输出:

[Wrapper.java:5] com.cisco.ruan.classloader.HaoClassLoader@248523a0 [Wrapper.java:8] com.cisco.ruan.classloader.RuanClassLoader@3c635421

因此,可以推断的是ClassA和ClassB的首先通过MyClassLoader加载,然后实际HaoClassLoader和RuanClassLoader加载.而且我认为这个实验可以看作是一个非常简单的OSGi捆绑类加载器机制的实现？对？

Answer 1

这在OSGi中完全正常.在OSGi中,每个包有一个类加载器.此类加载器为bundle中的所有类提供服务.对于bundle之外的所有类,都有Import-Package定义.在运行时,每个包导入都连接到导出包的包.当加载来自这样的包的类时,加载被委托给其他bundle类加载器.

让我们来看看你的场景.

Bundle osgi-server包含类com.cisco.ruan.server.HelloService它还导出包com.cisco.ruan.server.Bundle osgi-client导入包com.cisco.ruan.server.当您在osgi-client的Activator中加载HelloService类时,要求osgi-client的类加载器加载该类.它找到了一个包和委托加载到osgi-server的类加载器的委托.然后,该类加载器用户加载该类.

这是OSGi中的默认行为,如果你认为它通过它很有意义.