你好，OSGi (第一部分): Bundles入门
摘要：OSGi(Open Service Gateway Initiative，开放式服务通路倡议)为开发和部署模块化应用和库定义了基础架构。在本文中，Sunil Patil为我们介绍了OSGi开发的概念，并使用Eclipse自带的OSGi容器Equinox创建了一个简单的Hello World应用；同时，他还为我们简单介绍了如何使用OSGi开发面向服务(SOA)的应用程序，及如何使用ServiceFactory和ServiceTracter这两个类。
OSGi亦称做Java语言的动态模块系统，它为模块化应用的开发定义了一个基础架构。OSGi容器已有多家开源实现，比如Knoflerfish、Equinox和Apache的Felix。您可以通过这些容器，把您的应用程序劈分为多个模块单元，这样，您就可以更容易地管理这些模块单元之间的交叉依赖关系。
OSGi规范和Servlet规范及EJB规范类似，该规范定义了两种对象，一是容器对外提供的服务对象，另一个是容器和您的应用程序之间必须遵守的契约，其中，服务对象是容器要实现的。您如果想要在OSGi平台上进行开发，首先，您必须要使用OSGi API来创建您的应用，然后将之部署到OSGi容器中。从开发者的角度看，OSIG具有以下优点：
a) 您可以在不重启容器的情况下，动态地安装、卸载、启动和停止您的应用程序中的不同模块；
b) 对于您应用程序中的某一特定模块，容器可以同时运行该模块的多个版本；
c) OSGi为开发嵌入式应用、移动应用、富互联网应用(RIA)提供了非常优秀的基础架构
如果说您使用Servlet容器开发您的网络应用，使用EJB容器开发交易式应用，您可能会问，为什么我们还需要另外的容器呢？对这个问题的简短回答是，OSIG容器是专门为开发复杂的Java应用准备的，在这些应用的开发过程中，您非常需要将这些应用分割为一个个的模块。在本系列以后的文章中，我将针对这个问题进行展开并深入回答。
1. OSGi在企业开发中的应用
OSGi联盟(OSGi Alliance)于1999年3月开始着手制定OSGi规范，其主要目的就是要制定一套开放式标准，以便向局域网及其中的设备提供可管理的服务；其基本思路是，一旦您在网络设备（如服务器和嵌入式设备）上使用了OSGi服务平台，您就可以在网络上的任何地方管理这些设备上运行的软件组件的生命周期，可以在后台对这些组件进行安装、升级或卸载，但不需要打断该设备的正常运行。
近年来，OSGi技术在嵌入式系统及网络设备市场得到广泛应用。现在，由于Eclipse的成功，OSGi在企业开发中逐渐成为切实可行的、较有价值的一种技术。
1.1. 业界对OSGi的支持逐渐上升
2003年，Eclipse开发团队开始想办法提高Eclipse工具集的模块化，以便让它成为更加动态的富客户端平台。Eclipse团队最终选中OSGi框架作为其组件的运行时模型，2004年6月发布的Eclipse3.0就是第一个基于OSGi平台的版本。现在几乎所有的企业应用服务器都支持OSGi，Spring也通过一个叫“OSGi服务平台上的Spring动态模型(亦称之为OSGi Spring)”的项目来支持OSGi。该项目提供OSGi基础架构，以便我们在Spring的企业开发中更容易使用OSGi。
2. 开放源码的OSGi容器
从企业开发者的角度看，OSGi容器的要求很低，您可以很容易地把它嵌入到企业应用中，比如我们在开发Web应用时，我们可以把这个Web应用分为多个模块，一个模块负责视图层，另一个模块负责DAO层，第三个模块负责数据访问层，如果我们使用OSGi容器来管理这些模块之间的交叉依赖，我们就可以在不用重启该Web应用的前提下，将DAO层从速度较慢的升级到速度较快的DAO。
只要您的应用和OSGi规范兼容，您的应用就应该可以运行在任何OSGi容器中，现在比较流行的开放源码的OSGi容器有以下三种:
a) Equinox容器是参照OSGi规范第4版实现的，它构成了Eclipse IDE的核心—模块化的Java运行时；它实现了OSGi规范4中规定的必须强制实现的功能，同时，它也实现了OSGi规范中大部分的可选功能；
b) Knoflerfish是OSGi规范第3版和第4版的开源实现，它实现了OSGi规范规定的必须实现的功能及部分可选功能；
c) Apache的Felix是Apache软件基金会实现的OSGi开源容器，至本文截稿时为止，该容器还没有和OSGi规范完全兼容。在本文中，我们将使用Equonix作为我们的OSGi容器，如果您想了解更多关于Apache Felix和Knoflerfish容器的信息，请参考本文的资源部分。
3. 开发一个简单的Hello World的Bundle(OSGi绑定包)
在OSGi中，软件是以Bundle的形式发布的。一个Bundle由Java类和其它资源构成，它可为其它的Bundle提供服务，也可以导入其它Bundle中的Java包；同时，OSGi的Bundle也可以为其所在的设备提供一些功能。Eclipse为开发OSGi Bundle提供了优秀的支持，它不仅提供了向导来创建OSGi Bundle，而且还提供了内嵌的Equinox容器，您可以使用该容器执行和调试OSGi插件。请注意每一个Eclipse插件，从本质上说，都是一个OSGi Bundle，只是这个OSGi Bundle多加了一些Eclipse专用的代码而已。下面我们来看看如何使用Eclipse开发一个简单的OSGi的Hello World Bundle。
3.1. 新建Bundle
1) 在Eclipse中，点击“FileàNewàProject”菜单，您将会看到新项目创建对话框；
2) 在新项目对话框中，选择“Plug-in Project(插件项目)”并点击“Next(下一步)”按钮，您将看到插件项目对话框；
3) 在插件项目对话框中，请键入下列值：
Project Name(项目名称)：com.javaworld.sample.HelloWorld
Target Platform(目标平台)：an OSGi FrameworkàStandard （OSGi框架à标准）
4) 对其它的要求输入值采用缺省值，并点击“Next(下一步)”按钮，您将会看到插件上下文对话框；
5) 在插件上下文对话框中，请选择缺省值并点击“Next(下一步)”按钮；
6) 在模板对话框中，请选择“Hello OSGi Bundle（你好，OSGi包）”模板，然后点击“Finish(完成)”按钮完成该项目。
Eclipse将花几秒钟生成Hello World Bundle模板代码，它将新建两个文件：Activator.java和MANIFEST.MF，下面，让我们看看这两个文件：
3.1.1. Activator.java文件
源代码清单1. Activator.java
package com.javaworld.sample.helloworld;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
public class Activator implements BundleActivator {
public void start(BundleContext context) throws Exception {
System.out.println("Hello world");
}
public void stop(BundleContext context) throws Exception {
System.out.println("Goodbye World");
}
}
如果您想让您开发的Bundle能在其启动或关闭时通知自身，那么您应新建一个类，让它实现BundleActivator接口，同时，您还需要遵行下列规则：
这个实现了BundleActivator接口的类必须有一个public的、不带参数的构造函数，这样，OSGi框架就能调用该类的Class.newInstance()方法创建这个BundleActivator对象；
容器将调用Activator类的start()方法来启动Bundle，因此，我们可以在start()方法中执行一些资源初始化的操作，例如，我们可以在该方法中获取数据库连接，以备后用。这个start()方法的唯一参数是一个BundleObject对象，Bundles可以通过该对象和OSGi框架通讯，我们可以从该对象中获取OSGi容器相关的一些信息；如果某个Bundle抛出异常，容器将之置为“stopped(已停止)”状态，此时，这个Bundle就不能对外提供服务。
如果我们要关闭一个Bundle，容器将调用Activator类中的stop()方法。因此，我们可在stop()方法中执行一些资源清理任务，比如释放数据库连接。
一旦Activator类准备就绪，您就可以通过MANIFEST.MF文件把该包的合法名称传给容器。下面，我们就看看这个MANIFEST.MF文件。
3.1.2. MANIFEST.MF文件
该文件是Bundle的部署描述文件，其格式和正常JAR文件包中的MANIFEST.MF文件相同，因此它由一系列的属性及这些属性对应的值组成，属性名位于每一行的开头，我们可以称其为属性头。OSGi规范规定，您可以使用属性头向容器描述您的Bundle。您的Hello World Bundle的MANIFEST.MF文件看起来应该如清单2所示：
源代码清单2. Hello World Bundle中的MANIFEST.MF文件
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: HelloWorld Plug-in
Bundle-SymbolicName: com.javaworld.sample.HelloWorld
Bundle-Version: 1.0.0
Bundle-Activator: com.javaworld.sample.helloworld.Activator
Bundle-Vendor: JAVAWORLD
Bundle-Localization: plugin
Import-Package: org.osgi.framework;version="1.3.0"
我们来看看这个文件中使用的属性头：
Bundle-ManifestVersion
该属性头告诉OSGi容器，本Bundle将遵循OSGi规范，数值2表示本Bundle和OSGi规范第4版本兼容；如果该属性的数值为1，那么则表示本包和OSGi版本3或更早版本兼容。
Bundle-Name
该属性头为本Bundle定义了一个简短的、可以阅读的名称；
Bundle-SymbolicName
这个属性头为本Bundle定义了一个唯一的、非本地化的名字；当您需要从别的Bundles中访问某一指定的Bundle时，您就要使用这个名字。
Bundle-Version
该属性头给出了本Bundle的版本号。
Bundle-Activator
该属性头给出了本Bundle中使用的监听器类名字，这个属性值是可选的。监听器将对Activator中的start()和stop()方法监听。在程序清单2中，该属性头的值为com.javaworld.sample.helloworld.Activator。
Bundle-Vendor
该属性头是对本Bundle发行商的表述。
Bundle-Localization
该属性头包含了本Bundle的本地化文件所在的位置，我们的Hello World Bundle中并没有本地化文件，但Eclipse IDE仍自动产生这个属性头
Import-Package
该属性头定义了本Bundle中引入的Java包，我将在本文后面的依赖性管理小节中详细讲解这个问题。现在，Hello World Bundle已经准备就绪，让我们来运行并看看它的输出结果。
3.2. 运行Bundle
我在前面提到，Eclipse IDE中有一个内嵌的Equinox OSGi容器，您可以利用它来执行或调试OSGi Bundle。请按照下面步骤执行刚才的Hello World Bundle:
1 ) 单击RunàRun… 菜单(译者注，在Eclipse3.3中，请单击RunàOpen Run Diglog…菜单)；
2) Eclipse会打开“Create, manage and run configuration(新建、管理和运行配置)”对话框，请双击”Equinox OSGi Framework”按钮，Eclipse将打开运行时配置对话框；
3) 在上面的对话框中，将Name(名称)输入框的值改为Hello World Bundle；
4) 您会注意到在Workspace插件目录下，有一个名为com.javaworld.sample.HelloWorld的插件，请选中它；在Target Platform(目标平台)下，请确保org.eclipse.osgi插件被选中。您的Run(运行)对话框应该看起来如图1所示：
图1. Hello World Bundle的运行配置
5) 现在，请单击Run(运行)按钮，您应该看到控制台视图上打印出“Hello World”。其实，Eclipse是在控制台视图中打开OSGi控制台。
3.2.1. OSGi控制台
OSGi控制台是OSGi容器的命令行界面，您可以在这个控制台上启动、停止、安装、更新和删除Bundles。在Eclipse IDE中，请点击该控制台视图获得焦点，然后按回车键，这时您可以看到OSGi提示符，如图2所示：(译者注，在Eclipse3.3中，如果您没有看到OSGi提示符，请在图1的运行配置中，点击Arguments标签，然后在Program Arguments(程序参数)输入框中键入“-console”，然后再次运行该Bundle)。
图2. OSGi控制台和HelloWorldActivator.java
下面是几个经常使用的OSGi命令，您可以使用这些命令与OSGi容器进行交互。
ss: 该命令显示所有已安装的Bundles及它们的状态，它将显示Bundle ID，Bundle的简短名称及Bundle状态；
start <bundleid>: 该命令将启动一个Bundle；
stop <bundleid>: 该命令将停止一个Bundle；
update <bundleid>: 该命令使用新的JAR文件更新一个Bundle；
install <bundleid>: 该命令将一个新的Bundle安装到OSGi容器；
uninstall <bundleid>: 从OSGi容器中卸载一个已安装的Bundle。
请注意，这些命令是OSGi规范中规定的，因此，您可以使用它们和任何OSGi容器交互。
4. 依赖性管理
OSGi允许您把您的应用程序分成多个模块，并能管理这些模块之间的依赖性。为了达到这个目的，它引入了Bundle访问域的概念。Bundle中类的缺省访问范围只对本Bundle内部可见，但对其它任何Bundle都是不可见的；在Bundle内部，类的可访问性遵循Java语言的一般规范。那么，您如果想要从一个Bundle中访问另一个Bundle中的类，您应该怎么办呢？解决方法是将源Bundle中的包导出来，然后把它们导入到目标Bundle中。在本小结中，我们将通过一个示例程序说明这个概念。
首先，我们新建一个名com.javaworld.sample.HelloService的Bundle，并从其中导出一个包，然后将该包导入到我们的com.javaworld.sample.HelloWorld Bundle中。
4.1. 导出Java包
我们开始新建一个com.javaworld.sample.HelloService Bundle，并从其中导出一个Java包，具体步骤如下：
1) 新建com.javaworld.sample.HelloService Bundle，具体步骤请参见上小节中新建com.javaworld.sample.HelloWorld Bundle的步骤；
2) 在HelloService Bundle中，新建一个com.javaworld.sample.service.HelloService.java接口，其源代码如清单3所示。
源代码清单3. HelloService.java
package com.javaworld.sample.service;
public interface HelloService {
public String sayHello();
}
3) 新建类com.javaworld.sample.service.impl.HelloServiceImpl.java，该类实现HelloService接口，其源代码如清单4所示。
源代码清单4. HelloServiceImpl.java
package com.javaworld.sample.service.impl;
import com.javaworld.sample.service.HelloService;
public class HelloServiceImpl implements HelloService {
public String sayHello() {
System.out.println("Inside HelloServiceImple.sayHello()");
return "Say Hello";
}
}
4) 请在您的Eclipse Manifest编辑器中打开HelloService包中的MANIFEST.MF文件，点击“Runtime(运行时)” 标签，在“导出包”小节，单击“Add(添加)”按钮，并选择com.javaworld.sample.service包。这时，HelloService Bundle中的MANIFEST.MF文件代码应如源代码清单5所示。
源代码清单5. HelloService Bundle中的Manifest文件
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: HelloService Plug-in
Bundle-SymbolicName: com.javaworld.sample.HelloService
Bundle-Version: 1.0.0
Bundle-Vendor: JAVAWORLD
Bundle-Localization: plugin
Export-Package: com.javaworld.sample.service
Import-Package: org.osgi.framework;version="1.3.0"
您可以看到，HelloService Bundle中的MANIFEST.MF文件和HelloWorld Bundle非常相似，唯一的区别就是多了一个Export-Package属性头，该属性头的值为com.javaworld.sample.service；Export-Package属性头通知OSGi容器，其它Bundle可以从HelloService Bundle外面访问com.javaworld.sample.service包中的类。请注意，在示例代码中，我们只暴露了接口类HelloService，而没有暴露其实现类的HelloServiceImpl。
4.2. 导入Java包
下面，我们将从HelloService Bundle中导出的com.javaworld.sample.service包并将其导入到HelloWorld Bundle中，具体步骤如下：
1). 请在com.javaworld.sample.HelloWorld Bundle中找到MANIFEST.MF文件，并在Manifest编辑器中打开，点击“Dependencies(依赖性)”标签，然后点击“Import Package(导入包)”按钮，将com.javaworld.sample.service添加为导入包，这时，您的HelloWorld Bundle中的MANIFEST.MF文件内容应如源代码清单6所示：
源代码清单6. HelloWorld Bundle中的MANIFEST.MF文件
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: HelloWorld Plug-in
Bundle-SymbolicName: com.javaworld.sample.HelloWorld
Bundle-Version: 1.0.0
Bundle-Activator: com.javaworld.sample.helloworld.Activator
Bundle-Vendor: JAVAWORLD
Bundle-Localization: plugin
Import-Package: com.javaworld.sample.service,
org.osgi.framework;version="1.3.0"
从上面的代码可以看出，Import-Package属性头的值是一个由逗号分隔的字符串，这是您想导入包的列表。在HelloWorld Bundle示例代码中，我们引入了两个包，即com.javaworld.sample.service和org.osgi.framework。
org.osgi.framework包中包含有OSGi框架类，比如，在HelloWorld Bundle中的Activator.java中用到的BundleContext和BundleActivator类都属于这个包。
2) 下面，请在Eclipse Java编辑器中打开com.javaworld.sample.helloworld.Activator.java，您会注意到，您现在可以访问HelloService接口，但不能访问HelloServiceImpl实现类，这是因为HelloService Bunlde只导出了com.javaworld.sampel.service包，同时HelloWorld Bundle也导入了这个包。HelloServiceImpl是HelloService Bundle的一个内部类，任何其它的Bundle都不能访问它。
4.3. 类级别上的访问域
如果您运行示例的HelloService服务包，它会在Eclipse控制台上打印出”Hello World”。但是，如果您想在HelloWorld Bundle的Activator中访问HelloServiceImpl类，这时，编译没有问题，但在OSGi容器中运行这个Bundle时会抛出异常。
OSGi容器是如何能将jar文件中的一些类隐藏掉，而让另外一些类可见呢？这是因为OSGi容器使用Java类加载器来管理类的可见性，OSGi容器为每个Bundle创建不同的类加载器，因此每个Bundle能访问位于下列位置中的类：
a) 位于Java启动类路径下的、所有以Java.*开头的包中的类；
b) 位于OSGi框架类路径下的类，通常有一个独立的类加载器负责加载框架的实现类及关键的接口类；
c) 位于Bundle空间中的类，这些类通常包含在与Bundle相关的jar文件中，以及加到这个Bundle中的其它jar包中的类。
d) 导入包中的类，例如，HelloWorld Bundle导入了com.javaworld.sample.service包，因此它能访问该包中的类。Bundle级别的访问域是OSGi一个非常强大的功能，例如，它可以让您安全地更新HelloServiceImpl.java类，而不必担心依赖于这个类的代码受到破坏。
5. OSGi服务
前面我们提到，OSGi架构非常适合我们实现面向服务的应用(SOA)。它可以让Bundles导出服务，而其它的Bundles可以在不必了解源Bundles任何信息的情况下消费这些导出的服务。由于OSGi具有隐藏真实的服务实现类的能力，所有它为面向服务的应用提供了良好的类与接口的组合。
在OSGi框架中，源Bundle在OSGi容器中注册POJO对象，该对象不必实现任何接口，也不用继承任何超类，但它可以注册在一个或多个接口下，并对外提供服务。目标Bundle可以向OSGi容器请求注册在某一接口下的服务，一旦它发现该服务，目标Bundle就会将该服务绑定到这个接口，并能调用该接口中的方法。下面我们举个例子，以便我们能更好理解与OSGi相关的这些概念。
5.1. 导出服务
在本小节中，我们将更新HelloService Bundle，以便它能把HelloServiceImpl类的对象导出为服务，具体步骤如下：
1) 修改com.javaworld.sample.HelloService Bundle中的MANIFEST.MF文件，让它导入org.osgi.framework包（译者注，这一步我们已经完成）；
2) 新建Java类com.javaworld.sample.impl.HelloServiceActivator.java，其源代码如清单7所示；
源代码清单7. HelloServiceActivator.java
public class HelloServiceActivator implements BundleActivator {
ServiceRegistration helloServiceRegistration;
public void start(BundleContext context) throws Exception {
HelloService helloService = new HelloServiceImpl();
helloServiceRegistration =context.registerService(HelloService.class.getName(), helloService, null);
}
public void stop(BundleContext context) throws Exception {
helloServiceRegistration.unregister();
}
}
请注意，在源Bundle中，我们应使用BundleContext.registerService()方法导出服务，这个方法带三个参数：
a) 该方法第一个参数为您要注册的服务的接口名称。如果您想把您的服务注册到多个接口下，您需要新建一个String数组存放这些接口名，然后把这个数组作为第一个参数传给registerService()方法。在示例代码中，我们想把我们的服务导出到HelloServer接口名下；
b) 第二个参数是您要注册的服务的实际Java对象。在示例代码中，我们导出HelloServiceImpl类的对象，并将其作为服务；
c) 第三个参数为服务的属性，它是一个Dictionary对象。如果多个Bundle导出服务的接口名相同，目标Bundle就可以使用这些属性对源Bundle进行过滤，找到它感兴趣的服务。
3) 最后，请修改HelloService Bundle中的MANIFEST.MF文件，将Bundle-Activator属性头的值改为com.javaworld.sample.service.impl.HelloServiceActivator。
现在HelloService Bundle就可以导出HelloServiceImpl对象了。当OSGi容器启动HelloService Bundle时，它会将控制权交给HelloServiceActivator.java类，HelloServiceActivator将HelloServiceImpl对象注册为服务。下面，我们开始创建该服务的消费者。
5.2. 导入服务
在本小节中，我们将修改上面开发的HelloWorld Bundle，以便让它成为HelloService服务的消费者。您主要需要修改HelloWorld Bundle中的Activator.java代码，修改后的代码如源代码清单8所示：
源代码清单8. HelloWorld Bundle中的Activator.java
package com.javaworld.sample.helloworld;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import com.javaworld.sample.service.HelloService;
public class Activator implements BundleActivator {
ServiceReference helloServiceReference;
public void start(BundleContext context) throws Exception {
System.out.println("Hello World!!");
helloServiceReference= context.getServiceReference(HelloService.class.getName());
HelloService helloService =(HelloService)context.getService(helloServiceReference);
System.out.println(helloService.sayHello());
}
public void stop(BundleContext context) throws Exception {
System.out.println("Goodbye World!!");
context.ungetService(helloServiceReference);
}
}
在上面的代码中，BundleContext.getServiceReference()方法将为注册在HelloService接口下的服务返回一个ServiceReference对象。如果存在多个HelloService服务，该方法会返回排行最高的服务(服务的排行是通过Constants.SERVICE_RANKING属性指定的)。您一旦获得ServiceReference对象，您就可以调用其BundleContext.getService()方法获取真实的服务对象。
您可以参照运行Bundle的方法运行上面的示例应用，请点击“RunàRun…”菜单，并确保HelloWorld和HelloService这两个Bundle被选中。当您启动HelloService Bundle时，您会在控制台上看到“Inside HelloServiceImple.sayHello()”，这个消息是由HelloServiceImpl.sayHello()方法打印出来的。
5.3. 创建服务工厂
在上节中，我们学会了如何使用OSGi框架新建一个Java对象，并把它注册为一个服务，然后让其它的Bundle去消费这个服务。如果您看一下HelloServiceActivator.start()方法，您会注意到我们在start()方法中新建了HelloServiceImpl类对象，然后将它注册到HelloService接口名下。这样注册后，任何其它的Bundle在请求HelloService服务时，OSGi容器将返回同一对象。
在大多数情况下，这样的实现方法没有问题。但是，比如说我们要为每一个Bundle消费者返回不同的HelloServiceImpl对象，再比如说，您的服务对象要提供的服务为打开一个数据库连接，但并不是马上就打开它，而是在真正需要的时候才打开这个数据库连接。
对这两种情况，我们的解决方法是，新建一个类实现ServiceFactory接口，并把该类的对象注册为服务，但并不是注册实际的服务对象。一旦您完成这一步，其它Bundle在请求该服务时，您的ServiceFactory实现类将接管该请求，ServiceFactory会为每个Bundle新建一个服务对象，并将真实服务的创建时间延迟到有人真正需要该服务的时候。
下面我们将使用ServiceFactory更新我们上面开发的com.javaworld.sample.HelloService Bundle，具体步骤如下：
1) 新建工厂 类HelloServiceFactory.java，源代码如清单9所示。
源代码清单9 . HelloServiceFactory.java
public class HelloServiceFactory implements ServiceFactory{
private int usageCounter = 0;
public Object getService(Bundle bundle, ServiceRegistration registration) {
System.out.println("Create object of HelloService for " + bundle.getSymbolicName());
usageCounter++;
System.out.println("Number of bundles using service " + usageCounter);
HelloService helloService = new HelloServiceImpl();
return helloService;
}
public void ungetService(Bundle bundle, ServiceRegistration registration, Object service) {
System.out.println("Release object of HelloService for " + bundle.getSymbolicName());
usageCounter--;
System.out.println("Number of bundles using service " + usageCounter);
}
}
从上面的代码中，我们可以看到，ServiceFactory接口定义了两个方法：
a) getService()方法：当某个Bundle第一次使用BundleContext.getService(ServiceReference)方法请求一个服务对象时，OSGi框架会调用该方法。在源代码清单9中，我们用这个方法为每个Bundle新建并返回不同的HelloServiceImpl对象，如果这个对象不是null，OSGi框架会缓存这个对象。如果同一个Bundle再次调用BundleContext.getService(ServiceReference)方法，OSGi将返回同一个服务对象。
b) ungetService()方法：当Bundle释放服务时，OSGi容器可以调用该方法销毁服务对象。在源代码清单9中，我们使用usageCounter变量来跟踪服务的使用数目，并打印出该服务的客户端数量。
2) 修改HelloService Bundle中的HelloServiceActivator.java的start()方法，让它注册到ServiceFactory接口名下，而不是注册到HelloService接口。详细代码如清单10所示：
源代码清单10. 修改后的HelloService Bundle中的HelloServiceActivator.java
package com.javaworld.sample.service.impl;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import com.javaworld.sample.helloservice.HelloServiceFactory;
import com.javaworld.sample.service.HelloService;
public class HelloServiceActivator implements BundleActivator {
ServiceRegistration helloServiceRegistration;
public void start(BundleContext context) throws Exception {
HelloServiceFactory helloServiceFactory = new HelloServiceFactory();
helloServiceRegistration =context.registerService(HelloService.class.getName(), helloServiceFactory, null);
}
public void stop(BundleContext context) throws Exception {
helloServiceRegistration.unregister();
}
}
现在，您可以试运行示例代码。您会注意到，当HelloWorld Bundle启动时，服务计数器变为1；当HelloWorld Bundle停止时，服务计数器的数目将变为0。
5.4. 跟踪服务
在“OSGi服务”小节，您学会了如何使用服务的接口名搜索服务。但如果有多个Bundle使用同一接口名注册服务，那会发生什么呢？这时，OSGi容器将返回排行最高的服务，即，返回注册时那个SERVICE_RANKING属性值最大的服务。如果有多个服务的排行值相等，那么OSGi容器将返回PID值最小的那个服务。
但是，如果您的服务消费者需要了解某一接口下的服务对象何时注册、何时取消注册，这时，您应使用ServiceTracker类。下面，我们看看如何使用服务跟踪器来修改我们的示例代码，具体步骤如下。
1) 修改HelloWorld Bundle的MANIFEST.MF文件，让它导入org.osgi.util.tracker包；
2) 新建类HelloServiceTracker.java，其源代码参见清单11。
源代码清单11. HelloServiceTracker.java
public class HelloServiceTracker extends ServiceTracker { public HelloServiceTracker(BundleContext context) { super(context, HelloService.class.getName(),null); } public Object addingService(ServiceReference reference) { System.out.println("Inside HelloServiceTracker.addingService " + reference.getBundle()); return super.addingService(reference); } public void removedService(ServiceReference reference, Object service) { System.out.println("Inside HelloServiceTracker.removedService " + reference.getBundle()); super.removedService(reference, service); } }
在上面的HelloSerivceTracker类的构造函数中，您可以看到，我们把HelloService接口名传入其父类中，这相当于说，HelloServiceTracker应跟踪注册到HelloService接口名下的所有服务，HelloServiceTracker继承自ServiceTracker类，实现了下面两个方法：
a) addingService()方法：当Bundle使用接口名注册服务时，该方法将会被调用；
b) removedService()方法：当Bundle取消注册某个接口名下的服务时，该方法将会被调用。
3) 用HelloServiceTracker类更新我们的Activator.java类，以便让它来管理服务，而不是直接去查找它们，源代码请参见清单12。
源代码清单12. 使用了HelloServiceTracker的Activator.java
public class Activator implements BundleActivator { HelloServiceTracker helloServiceTracker; public void start(BundleContext context) throws Exception { System.out.println("Hello World!!"); helloServiceTracker= new HelloServiceTracker(context); helloServiceTracker.open(); HelloService helloService = (HelloService)helloServiceTracker.getService(); System.out.println(helloService.sayHello()); } public void stop(BundleContext context) throws Exception { System.out.println("Goodbye World!!"); helloServiceTracker.close(); } }
我们看到，在初始的start()方法中，我们首先新建一个HelloServiceTracker对象，然后要求这个对象跟踪HelloService接口下的服务。这时，我们可以调用getService()方法获得HelloService对象。
如果您试运行上面的示例代码，您会注意到，在启动或停止HelloSerivce Bundle时，OSGi容器都会调用HelloServiceTracker对象的addingService()方法或removedService()方法。
6. 结论
这是“你好，OSGi”系列三篇文章的第一篇，我向您介绍了使用OSGi进行模块化应用开发的一些基本概念。您现在已了解到，当前有三种开源的OSGi容器，而且您还练习了如何使用Eclipse自带的OSGi容器Equinox开发一个简单的Bundle；同时，您也学会了Bundle之间是怎样通过导出导入彼此的包和服务，从而达到彼此交互的目的。
在本文中，您也许注意到，开发OSGi Bundle的一个挑战是，您的每个Bundle都需要了解OSGi API，在某些开发场景中，这可能意味着我们要许多基础代码。在本系列的下一篇文章中，我将向您介绍“Spring Dynamic Modules for OSGi Service Platforms(OSG服务平台的Spring动态模块，亦称为Spring OSGi)”项目，该项目将会简化OSGi Bundle 的开发。另外，您也可以参考本文的资源部分，学习更多关于OSGi的知识。
7. 作者介绍
Sunil Patil是一位Java企业/门户开发者，现就职于加州三藩市的Ascendent Technology公司。他是Java Portlets 101一书的作者(该书由SourceBeat公司2007年4月出版)，而且，他还写了许多文章，通过O’Reilly Media发表。Sunil曾经在IBM的Websphere Portal Server开发团队工作过3年。现在，他积极参与Pluto社区。另外，他拥有IBM Websphere Portal Server 5.0和5.1版本的开发者证书，Sun 的SCJP证书和Web组件开发者证书，同时，他还是商务组件的开发者。您可以访问Sunil的博客：http://jroller.com/page/SunilPatil。
8. 资源
非官方的OSGi规范开始于1999年，最近，JSR对Java模块化支持分为两个规范，即，JSR 277(Java模块系统，http://jcp.org/en/jsr/detail?id=277 )和JSR 291(Java动态组件支持，http://jcp.org/en/jsr/detail?id=291 )。在这两个JSR规范中，人们对哪个规范应该包含在Java EE6中，有过很多争议，请参考http://www.infoq.com/news/2007/08/osgi-jsr277-debate 。
和许多Java开发者一样，Sebastien Arbogast最近意识到OSGi的重要性（请参见http://osgi.dzone.com/news/why-osgi-zone )，他在Javalobby上开辟了OSGi专区(请参见http://osgi.dzone.com/ )，作为OSGi相关信息和讨论的平台。
如果您想了解OSGi服务规范第4版的信息，请参考http://www2.osgi.org/Release4/HomePage；关于OSGi服务规范第4版的Java API，请参考http://www2.osgi.org/javadoc/r4/；关于OSG服务平台的Spring动态模块项目，有时也称作Spring OSGi项目，请参考http://www.springframework.org/osgi。