TECHNOLOGY

[Objective-C]分数类

2008-12-14T22:00:00.000+08:00

// FILE FractionNumber.h

#import

@interface FractionNumber : NSObject {

int numerator;

int denominator;

}

@property(readwrite) int numerator, denominator;

-(id)initWithIntegers:(int)x numbery:(int)y;

- (NSString *)stringValue;

- (float)floatValue;

- (double)doubleValue;

- (void)add:(FractionNumber *)fn;

- (void)sub:(FractionNumber *)fn;

- (void)div:(FractionNumber *)fn;

- (void)mul:(FractionNumber *)fn;

+(int)gcd:(int)x numbery:(int)y;

+(int)lcm:(int)x numbery:(int)y;

+ (FractionNumber *)parseFractionNumberWithString:(NSString *)stringNumber;

+ (FractionNumber *)parseFractionNumberWithFloat:(double)floatNumber;

+ (FractionNumber *)parseFractionNumberWithInteger:(int)intNumber;

@end

// FILE FractionNumber.m

#import "FractionNumber.h"

@implementation FractionNumber

@synthesize numerator, denominator;

-(id)init

{

[super init];

numerator = 0;

denominator = 1;

return self;

}

-(id)initWithIntegers:(int)x numbery:(int)y

{

[super init];

numerator = x;

denominator = y;

return self;

}

- (NSString *)stringValue

{

return [[NSString alloc] initWithFormat:@"%.11g", [self doubleValue]];

}

- (float)floatValue

{

return (float)numerator/(float)denominator;

}

- (double)doubleValue

{

return (double)numerator/(double)denominator;

}

- (id)copy

{

FractionNumber *fn = [[FractionNumber alloc] initWithIntegers:numerator numbery:denominator];

return fn;

}

- (void)add:(FractionNumber *)fn

{

int x1 = numerator;

int y1 = denominator;

int x2 = [fn numerator];

int y2 = [fn denominator];

int lcmnum = [FractionNumber lcm:y1 numbery:y2];

x1 = lcmnum / y1 * x1;

x2 = lcmnum / y2 * x2;

numerator = x1 + x2;

denominator = lcmnum;

int gcdnum = [FractionNumber gcd:numerator numbery:denominator];

while (gcdnum > 1)

{

numerator /= gcdnum;

denominator /= gcdnum;

gcdnum = [FractionNumber gcd:numerator numbery:denominator];

}

- (void)sub:(FractionNumber *)fn

{

int x1 = numerator;

int y1 = denominator;

int x2 = [fn numerator];

int y2 = [fn denominator];

int lcmnum = [FractionNumber lcm:y1 numbery:y2];

x1 = lcmnum / y1 * x1;

x2 = lcmnum / y2 * x2;

numerator = x1 - x2;

denominator = lcmnum;

int gcdnum = [FractionNumber gcd:numerator numbery:denominator];

while (gcdnum > 1)

{

numerator /= gcdnum;

denominator /= gcdnum;

gcdnum = [FractionNumber gcd:numerator numbery:denominator];

}

- (void)div:(FractionNumber *)fn

{

FractionNumber *newFn = [[FractionNumber alloc] initWithIntegers:[fn denominator] numbery:[fn numerator]];

[self mul:newFn];

[newFn release];

}

- (void)mul:(FractionNumber *)fn

{

int x1 = numerator;

int y1 = denominator;

int x2 = [fn numerator];

int y2 = [fn denominator];

int gcdnum = [FractionNumber gcd:x1 numbery:y2];

while(gcdnum > 1)

{

x1 /= gcdnum;

y2 /= gcdnum;

gcdnum = [FractionNumber gcd:x1 numbery:y2];

}

gcdnum = [FractionNumber gcd:x2 numbery:y1];

while(gcdnum > 1)

{

x2 /= gcdnum;

y1 /= gcdnum;

gcdnum = [FractionNumber gcd:x2 numbery:y1];

}

numerator = x1 * x2;

denominator = y1 * y2;

}

+(int)gcd:(int)x numbery:(int)y

{

return (!y)?x:[self gcd:y numbery:x%y];

}

+(int)lcm:(int)x numbery:(int)y

{

int y1 = x;

int y2 = y;

int gcdnum = [FractionNumber gcd:y1 numbery:y2];

while(gcdnum > 1)

{

y1 /= gcdnum;

y2 /= gcdnum;

gcdnum = [FractionNumber gcd:y1 numbery:y2];

}

return x * y1;

}

+(FractionNumber *)parseFractionNumberWithString:(NSString *)stringNumber

{

if (!stringNumber || [stringNumber length] == 0)

return NULL;

NSRange range = [stringNumber rangeOfString:@"."];

if (range.location == NSNotFound)

{

int number = [stringNumber intValue];

return [FractionNumber parseFractionNumberWithInteger:number];

}

else

{

@try {

[stringNumber doubleValue];

}

@catch (NSException * e) {

@throw e;

}

int floatNumberLength = [stringNumber length] - range.location - 1;

int ten = pow(10, floatNumberLength);

NSArray *numberparts = [stringNumber componentsSeparatedByString:@"."];

int x = [(NSString *)[numberparts objectAtIndex:1] intValue];

//x = (x * (ten - 1) + x);

//int y = ((ten - 1) * ten);

int y = ten;

int gcdnum = [FractionNumber gcd:x numbery:y];

while (gcdnum > 1)

{

x /= gcdnum;

y /= gcdnum;

gcdnum = [FractionNumber gcd:x numbery:y];

}

int num = [(NSString *)[numberparts objectAtIndex:0] intValue];

x += num * y;

FractionNumber *fn = [[FractionNumber alloc] initWithIntegers:x numbery:y];

return fn;

}

+(FractionNumber *)parseFractionNumberWithFloat:(double)floatNumber

{

NSString *numberString = [[NSString alloc] initWithFormat:@"%.11g", floatNumber];

FractionNumber *fn = [FractionNumber parseFractionNumberWithString:numberString];

[numberString release];

return fn;

}

+(FractionNumber *)parseFractionNumberWithInteger:(int)intNumber

{

FractionNumber *fn = [[FractionNumber alloc] initWithIntegers:intNumber numbery:1];

return fn;

}

@end

[JAVA]OSGi开发之Event:事件处理

2008-07-24T23:47:00.003+08:00

首先配置OSGi Framework的运行环境，我的Eclipse是3.3的，运行环境需要以下的Bundle：

org.eclipse.osgi
org.eclipse.equinox.ds
org.eclipse.equinox.registry
org.eclipse.equinox.common
org.eclipse.equinox.log
org.eclipse.osgi.services
org.eclipse.equinox.event
org.eclipse.osgi.util

操作步骤：点击菜单Run->Open Run Dialog…，在左侧的列表中，找到OSGi Framework，右键单击，New，修改Name为EventDemo，并在Bundles选项卡中，选中以上列举的Bundle，然后点击Apply，点Run。

在Console中输入ss来查看我们的环境是否成功运行：

osgi> ss

Framework is launched.

id State Bundle

0 ACTIVE org.eclipse.osgi_3.3.1.R33x_v20070828

1 ACTIVE org.eclipse.equinox.common_3.3.0.v20070426

2 ACTIVE org.eclipse.equinox.log_1.0.100.v20070226

3 ACTIVE org.eclipse.equinox.ds_1.0.0.qualifier

4 ACTIVE org.eclipse.equinox.registry_3.3.1.R33x_v20070802

5 ACTIVE org.eclipse.osgi.services_3.1.200.v20070605

6 ACTIVE org.eclipse.equinox.event_1.0.100.v20070516

7 ACTIVE org.eclipse.osgi.util_3.1.200.v20070605

osgi>

OK，这样我们的Spring-OSGi的环境就启动好了，现在先关闭它。我们来建立一个Plug-in Project，命名为：EventPublisher。

首先新建一个类：com.demo.eventpublisher.Log，代码如下：

package com.demo.eventpublisher;

import org.osgi.framework.BundleContext;

import org.osgi.service.log.LogService;

import org.osgi.util.tracker.ServiceTracker;

/**

* Utility class with static methods for logging to LogService, if available

* @version $Revision: 1.1 $

public class Log {

static private ServiceTracker logTracker;

private Log() {

}

public static void init(BundleContext bc) {

logTracker = new ServiceTracker(bc, LogService.class.getName(), null);

logTracker.open();

}

static void dispose() {

if (logTracker != null) {

logTracker.close();

}

logTracker = null;

}

public static void log(int level, String message) {

log(level, message, null);、

}

public static void log(int level, String message, Throwable e) {

LogService logService = (LogService) logTracker.getService();

if (logService != null) {

logService.log(level, message, e);

}

public static void info(String message)

{

info(message, null);

}

public static void info(String message, Throwable e)

{

log(LogService.LOG_INFO, message, e);

}

接下来创建一个循环发布事件的线程：com.demo.eventpublisher.TimerEvent，代码如下：

package com.demo.eventpublisher;

import java.util.Calendar;

import java.util.Hashtable;

import org.osgi.framework.BundleActivator;

import org.osgi.framework.BundleContext;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

import org.osgi.util.tracker.ServiceTracker;

public class TimerEvent extends Thread implements BundleActivator {

Hashtable time = new Hashtable();

ServiceTracker tracker;

public TimerEvent() {

super("TimerEvent");

}

public void start(BundleContext context) {

Log.init(context);

tracker = new ServiceTracker(context, EventAdmin.class.getName(), null);

tracker.open();

start();

}

public void stop(BundleContext context) {

interrupt();

tracker.close();

Log.dispose();

}

public void run() {

while (!Thread.interrupted())

try {

Log.info("Rasie Event");

Calendar c = Calendar.getInstance();

set(c, Calendar.MINUTE, "minutes");

set(c, Calendar.HOUR, "hours");

set(c, Calendar.DAY_OF_MONTH, "day");

set(c, Calendar.MONTH, "month");

set(c, Calendar.YEAR, "year");

EventAdmin ea = (EventAdmin) tracker.getService();

if (ea != null)

ea.sendEvent(new Event("com/demo/timer", time));

Thread.sleep(60000 - c.get(Calendar.SECOND) * 1000);

}

catch (InterruptedException e) {

// 忽略

}

void set(Calendar c, int field, String key) {

time.put(key, new Integer(c.get(field)));

}

在Plug-in ManiFest Editor中打开META-INF/MANIFEST.MF，如果安装了PDE，将会默认使用Plug-in ManiFest Editor打开。将Activator设置为com.demo.eventpublisher.TimerEvent，此时MANIFEST.MF文件中的内容如下：

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: EventPublisher Plug-in

Bundle-SymbolicName: EventPublisher

Bundle-Version: 1.0.0

Bundle-Activator: com.demo.eventpublisher.TimerEvent

Import-Package: org.osgi.framework;version="1.3.0",

org.osgi.service.event;version="1.1.0",

org.osgi.service.log;version="1.3.0",

org.osgi.util.tracker;version="1.3.2"

注意：手工写MANIFEST.MF文件时，最后一行一定要有一个回车。

接下来我们再来建立一个Plug-in Project，命名为EventHander。

我们建立一个类，名为：com.demo.eventhandler.CustomEventHandler，代码如下

package com.demo.eventhandler;

import java.util.Dictionary;

import java.util.Hashtable;

import org.osgi.framework.BundleContext;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventConstants;

import org.osgi.service.event.EventHandler;

import com.demo.internal.Log;

public class CustomEventHandler implements EventHandler

{

public final static String [] topics = new String[] {

// "org/osgi/service/log/LogEntry/LOG_INFO",

// "org/osgi/service/log/LogEntry/LOG_WARNING",

// "org/osgi/framework/ServiceEvent/REGISTERED",

// "org/osgi/framework/ServiceEvent/MODIFIED",

// "org/osgi/framework/ServiceEvent/UNREGISTERING",

// "org/osgi/framework/FrameworkEvent/STARTED",

// "org/osgi/service/log/LogEntry/LOG_ERROR",

"com/demo/timer"};

public void registry(BundleContext context)

{

Dictionary d = new Hashtable();

d.put(EventConstants.EVENT_TOPIC, topics );

context.registerService( EventHandler.class.getName(), this, d );

}

public void handleEvent(Event event)

{

if ("com/acme/timer".equals(event.getTopic()))

{

Log.info("Received event, EventTopic " + event.getTopic() + " " + event.getProperty("year") + "-" + event.getProperty("month") + "-" + event.getProperty("day"));

}

else

{

Log.info("Received event, EventTopic " + event.getTopic());

}

我们再建立一个Activator，名为：com.demo.eventhandler.internal.Activator，代码如下

package com.demo.internal;

import org.osgi.framework.BundleActivator;

import org.osgi.framework.BundleContext;

import com.demo.eventhandler.CustomEventHandler;

public class Activator implements BundleActivator

{

public void start(BundleContext context) throws Exception

{

Log.init(context);

CustomEventHandler eventhandler = new CustomEventHandler();

eventhandler.registry(context);

}

public void stop(BundleContext context) throws Exception

{

Log.dispose();

}

OK，我们将新建立的这两个Bundle加入到运行环境中，Run。

在Console中等待大约60秒后，输入log后可以在最后找到如下日志信息：

引用原文:

>Info [1] Rasie Event initial@reference:file:../../../../../../../../Documents/workspace/EventPublisher/

>Info [7] Received event, EventTopic com/demo/timer initial@reference:file:../../../../../../../../Documents/workspace/ConsumerServiceDemo/

瞧，我们已经收到打印出来的事件接收信息了 Received event, EventTopic com/demo/timer

[JAVA] OSGi入门：Declarative Services和依赖[译]

2008-06-25T15:14:00.005+08:00

欢迎回来EclipseZone"OSGi入门"系列讲座。进入到今天这节课之前我希望你能找到所有讲座以前的部分在我的个人博客上。

上次我们首次接触了Declarative Service。这次我们将看看Declarative Service的消费者那边。记得以前我们注册了一个服务在java.lang.Runnable接口下；现在我们将创建一个组件依赖在这个服务上。

正如讨论的那样，Declarative Services规范是所有关于让你聚焦于你的代码的应用逻辑上，而不是在以前的课程中写的OSGi"glue"代码。鉴于此，我们只是潜入到代码中，但是因此我们需要创建一个项目。以下是最后课程中同样的步骤，但是使用"SimpleImporter"作为项目名称。

现在从你的浏览器复制以下代码并粘帖到新建的Eclipse工程中的src文件夹里面：

package org.example.ds;

import org.eclipse.osgi.framework.console.CommandInterpreter;

import org.eclipse.osgi.framework.console.CommandProvider;

public class SampleCommandProvider1 implements CommandProvider {

private Runnable runnable;

public synchronized void setRunnable(Runnable r) {

runnable = r;

}

public synchronized void unsetRunnable(Runnable r) {

runnable = null;

}

public synchronized void _run(CommandInterpreter ci) {

if(runnable != null) {

runnable.run();

} else {

ci.println("Error, no Runnable available");

}

public String getHelp() {

return "\trun - execute a Runnable service";

}

这个类实现了CommandProvider接口，这是个用来扩展当你运行Equinox的时候在"osgi>"提示符中有效的命令集合。写一个CommandProvider的原因是用来提供一个方便我们测试代码互动性的方法。在IBM developerWork上的Chris Aniszczyk的文章中有更多命令提供器的详细讨论。

注意我们在这个类中没有调用任何OSGi API，事实上我们甚至无需从org.osgi.*包导入任何东西。我们依赖的这个服务——在这个情况中，一个java.lang.Runnable的实例——我们通过setRunnable方法提供使用并使用unsetRunnable方法带走它。我们可以认为这是一种依赖注入的形式。

其他的两个方法，getHelp和_run是为命令提供器实现的。没错，"_run"是个有趣的名称，它以下划线开头，但是那仅仅是一个Equinox控制台API的奇怪的特性，并且OSGi或者Declarative Service什么都不做。使用下划线开头模式的方法在Equinox控制台中变成命令，所以通过提供一个叫做_run的方法我们添加了一个命令"run"。另外注意的事情关于这个类我们需要关心确保runnable字段能够以线程安全的方式被更新和访问。线程安全在OSGi中相当重要，因为它本质上就是多线程的。坦率的说，我们始终应该把我们的代码写成线程安全的。

如以前一样，我们需要提供一个XML文件包含DS声明得到这些。复制以下到OSGI-INF/commandprovider1.xml到你的plug-in项目中：

<?xml version="1.0" encoding="UTF-8"?>

</service>

<reference name="RUNNABLE"

interface="java.lang.Runnable"

bind="setRunnable"

unbind="unsetRunnable"

cardinality="0..1"

policy="dynamic"/>

</component>

这是我们上次叙述疏忽了的另一个重要的步骤。(感谢Seamus Venasse指出来。)你需要编辑build.properties文件到在你的plug-in项目中，并且检查OSGI-INF文件夹是否选中。当Bundle使用Eclipse的导出向导导出时必须保证文件夹被包含在里面，或者使用PDE Build来建立。

那么我们需要添加下面一行到Bundle的manifest中：

1	Service-Component: OSGI-INF/commandprovider1.xml

这个定义有我们之前看过的同样的两个元素，implementation和service节点。implementation节点提供实现组件的类的名称，service节点告诉DS像一个服务那样注册这个组件。这种情况下我们注册到CommandProvider接口下，这个是我们如何让Equinox控制台获知关于我们的命令提供器的存在。

下个节点叫做reference，是我们以前没有见过的——它对DS声明了我们的组件已经依赖在一个服务上。name属性只是一个依赖的名称的随意的字符串(我们仍然不需要担心这个是用来干什么的)并且interface属性指定我们依赖的接口的名称。bind属性是当一个服务有效时将调用实现的类中的一个方法名称，换句话说，当一个Runnable服务用Service Registry注册了，DS将获取一个此新服务的引用并提供使用这个指定的方法提供给我们的组件。同样的unbind属性是当我们使用的一个服务变成无效的时候通过DS调用它。

Cardinality属性显示了DS真正的强大。这个属性控制是否这个依赖是可选的或是必需的，并且是否它是单独的或多个的。可能的值有：

引用原文:

? 0..1：可选和单个，"0或1"

? 1..1：有且仅有一个，"只有一个"

? 0..n：可选和多个，"0到多"

? 1..n：必须或者多个，"0到多"或"至少一个"

在这个例子中我们选择可选和单个，意味着我们的命令提供器能够应付依赖服务变成无效的情况。回来看看_run方法的代码，你可以看到它必须处理检查到null的情况。

让我们看看如果我们运行了这个Bundle会发生什么。如果你的SimpleExporterBundle从上次一直存在，当你在命令行提示符osgi>输入"run"你将看到如下响应：

1	Hello from SampleRunnable

太好了！这次确定了我们成功的导入了上节课我们写的Runnable服务。现在试着使用"stop"命令关闭SampleExporter的Bundle。当你再次输入"run"命令，你将看到：

1	Error, no Runnable available

DS通知的意思是Runnable服务消失了，并且调用了我们的unsetRunnable方法让我们知道。

再看看cardinality属性，如果我们改变成"1..1"你认为将会发生什么，例如从一个可选到必须的依赖切换过来？试着换下并重启动Equinox。如果SampleExporter的Bundle是激活的当我们输入"run"之后我们将看到和之前一样的信息"Hello from SampleRunnable"。但是，如果SampleExporter是未激活的之后我们将看到一个与之前非常不同的错误信息。事实上，我们将看到Equinox的控制台帮助信息，那是对于未被识别的命令的标准响应。这表示我们的命令提供其它自己已经通过DS注销了！直到组件有一个必须的依赖前都不会满足，DS只能被迫撤消它提供的任何服务。反过来说Equinox控制台忘掉了"run"命令。

你可能会对policy属性感到奇怪，知道现在我仍然没有提及。这个值是"static"或"dynamic"中的一个，它指出是否这个组件能够应付服务的动态切换。如果不是动态的，那么每次目标服务改变了它必须为DS撤消组件并创建一个新的实例。正如你可能期望的，这相当于一个重量级的方法，最好编码你的组件来支持任何时候可能的动态切换。不幸的是默认值是static，所以你一定要记得明确的设置它为dynamic。

那么我们看过了可选单一和仅一个，但是什么是多重依赖呢？可能在Service Registry中存在多余一个的Runnable，并且如果我们只绑定它们中间的一个之后选择的那一个我们得到的是任意的。。或许我们喜欢实现一个"runall"命令来运行所有的当前注册了的Runnable。

如果我们改变cardinality为"0..n"的话将会发生什么？在某一方面它将总是运作：代替只调用一次setRunnable方法，DS将为每个Registry中的Runnable实例调用setRunnable一次。问题是我们写的类将会混乱。代替设置一个单独的Runnable字段，我们需要储存Runnable到一个集合。在这里类的版本有细小的改变，即将重新复制并粘贴到你的项目的src文件夹中：

package org.example.ds;

import java.util.*;

import org.eclipse.osgi.framework.console.CommandInterpreter;

import org.eclipse.osgi.framework.console.CommandProvider;

public class SampleCommandProvider2 implements CommandProvider {

private List<Runnable> runnables =

Collections.synchronizedList(new ArrayList<Runnable>());

public void addRunnable(Runnable r) {

runnables.add(r);

}

public void removeRunnable(Runnable r) {

runnables.remove(r);

}

public void _runall(CommandInterpreter ci) {

synchronized(runnables) {

for(Runnable r : runnables) {

r.run();

}

public String getHelp() {

return "\trunall - Run all registered Runnables";

}

现在创建OSGI-INF/commandprovider2.xml并复制以下内容：

<?xml version="1.0" encoding="UTF-8"?>

</service>

<reference name="RUNNABLE"

interface="java.lang.Runnable"

bind="addRunnable"

unbind="removeRunnable"

cardinality="0..n"

policy="dynamic"/>

</component>

最终添加这个文件到manifest的Service-Component头去，看起来就像这样：

1 2	Service-Component: OSGI-INF/commandprovider1.xml, OSGI-INF/commandprovider2.xml

这个声明同之前的一样不可缺少，除了我们对bind和unbind方法重命名并改变cardinality为"0..n"。就像练习一样，试着注册一些附加的Runnable服务并检查"runall"命令执行它们全部。下次，如果我们改变cardinality为"1..n"你认为会将会发生什么呢？尝试着验证你的想象。

That's all for this lesson. Remember that the OSGi Alliance Community Event is happening next week in Munich, Germany, and I believe it's still not too late to register . See you there!

[JAVA]OSGi入门：介绍Declarative Services[译]

2008-06-25T15:14:00.004+08:00

欢迎来到"OSGi入门"系列的下个部分。这个部分十分的有趣，因为我们将开始尝试使用Declarative Services。

Declarative Service(或者"DS")规范是OSGi最新的一个部分，并且它来自于跨越Bundle将服务配置到一起的结果。并非这个任务困难——正如我希望我以前讲课中展示的——它需要相当数量的样板代码。它也要求你对内容的条理很谨慎，也就是说你很容易搬起石头砸自己的脚。

早期试图解决此问题的是一个叫做Service Binder的工具。由 Humberto Cervantes 和 Richard Hall 开发的工具。Service Binder引入了自动化的服务依赖关系管理，允许开发人员可以集中精力编写他们的服务。服务之间的配置通过声明处理，并且声明都写在XML中。

这个Declarative Service规范是从Service Binder进化而来，并且是OSGi的4.0版本的一个标准部分。那么，让我们看看它能做什么。

正如我在课程的上一个部分叙述的，我厌倦了在命令行做任何事情：从这点上，我将使用Eclipse SDK。请记住我所介绍的事实上并不依赖Eclipse。虽然Eclipse对我们有或多或少的帮助，不过没什么黑色魔法，所以我们在这里看到的任何东西在NetBeans、IntelliJ甚至在老旧的vi上都是完全可行的。

第一件事，我们需要下载Declarative Services的Equinox实现。假如你使用当前稳定的Eclipse版本是3.2.2，那就从这里下载。如果你使用不同的版本，你需要从顶层的Equinox下载页找到这个版本，并下载org.eclipse.equinox.ds_x.x.x_xxxxx.jar文件。把下载下来的文件放到你的Eclipse安装目录的plugins下，并重启Eclipse。事实上，如果你已经对Eclipse Plug-in开发有一点点了解，你可以把这个jar文件放入你的目标平台文件夹下。如果你不知道什么是"目标平台"，不用担心，只要把这个jar放到plugins目录下就可以了。

现在，我们将创建一个新的Bundle。做这些事情，我们使用Eclipse中的Plug-in项目向导来创建一个项目：[list=decimal]

从主菜单，选择File->New->Project

选择Plug-in Project并单击下一步

输入项目名称：SimpleExporter

在底部，"This plug-in is targeted to run with"文字下面，选择"an OSGi framework"之后在下拉框中选择"standard"。这一步不是绝对必须的，它只是防止我们使用盒外无效的其他OSGi框架实现的特性。

单击下一步。在向导接下来的页面中，取消选中的"Generate an activator"复选框。单击结束
[/list]

我们现在有个空的Bundle项目，所以我们需要添加一些代码。为了尽可能的简单，我们将提供一个使用了在所有的Java Runtime中都有效的接口：java.lang.Runnable，使用一个顺手的小的Eclipse快捷方式，仅仅从你的浏览器复制下面的代码，然后选择SampleExporter项目中的src文件夹并点击Edit -> Paste。Eclipse将为你创建包和源文件。

package org.example.ds;

public class SampleRunnable implements Runnable {

public void run() {

System.out.println("Hello from SampleRunnable");

}

到目前为止我们没有看到任何新东西，但是，接下来会有趣些：我们将创建一个XML文件来声明SampleRunnable为一个服务。在顶级目录下创建一个名为OSGI-INF的文件夹，并复制下面的例子到文件samplerunnable.xml中：

<?xml version="1.0" encoding="UTF-8"?>

</service>

</component>

这是我们将看到的DS中简单声明中的一个。它描述了一个提供一个服务到OSGI Service Registry的叫做"samplerunnable"的在java.lang.Runnable下的组件，并且这个组件通过类org.example.ds.SampleRunnable来实现。

最后一步是告诉Declarative Service运行时关于这个XML文件的存在。我们为Bundle做这个事情是通过添加一个字段到MANIFEST.MF文件。因此，在编辑器中打开manifest(试着右键点击这个项目并选择PDE工具 -> Open Manifest)，跳到名为"MANIFEST.MF"的标签，这允许我们直接编辑manifest的文本内容。添加下面的一行：

1	Service-Component: OSGI-INF/samplerunnable.xml

然后保存这个文件。正如在上个部分中说的，manifest的最后一个空行是非常重要的，但是不像以前，如果你忘记了，你将从Eclipse获得一个错误信息。

在走的更远之前，让我们运行Equniox来检查这些工作。在Run菜单中选择"Run…"。对话框打开后，在左边的树形列表中选择"Equniox OSGi Framework"，然后点击New按钮。如果你是一个有经验的Eclipse用户但是没有做过OSGI开发，这个对话框可能看上去有些陌生。第一个标签是Bundles，允许我们选择哪些Bundles将包含在运行配置中，并且是否我们将在启动时便初始化。要获得最小集合，点击Deselect All并仅对以下Bundles做标记
[list=decimal]

SampleExporter(underneath Workspace)

org.eclipse.equniox.ds(underneath Target Platform)
[/list]

这些是我们感兴趣的Bundles，但是它们有些依赖，所以单击Add Required Bundles来添加那些依赖。所以，更好的主意是选中"Validate bundles automatically prior to launching"。最后，点击Run，并稍等片刻，osgi>提示符将出现在Eclipse控制台中。OSGi框架正在运行，并且你可以使用你以前学过的相同的命令与之交互。

那么是否我们的服务被注册了？我么可以通过键入services命令来检查。在服务列表中的某个地方—可能在底部—你将看到如下显示：

{java.lang.Runnable}={component.name=samplerunnable, component.id=1, service.id=22}

Registered by bundle: initial@reference:file:..../SampleExporter/ [5]

No bundles using service.

是的，它被注册了！并且注意一件重要的事情：它通过我们的Bundle注册的，不是通过Declarative Services Bundle。事实上DS代表了我们的Bundle注册了它。我们将迟些了解它如何做的，但是这节课的目的，足够说明了我们的服务的消费者不需要任何具体的工作，事实上，它们连我们使用Declarative Services也不必知道。如果那些消费者愿意那可以很好的使用Declarative Services，但是它们也能使用简单的OSGi代码。

另外要注意的是在我们的Bundle中，没有具体的OSGi的Java代码。换句话说，我们写了个POJO类，这是Declarative Services的一个主要特性。

这些就够了，我很抱歉，这节课程只是一个小小的基础。下次，我们将看看如何用DS以不同的方式消费服务，这将真正的展示出DS提供的的强大和便利。

参考:
本文原文http://www.eclipsezone.com/eclipse/forums/t96740.html

[JAVA]OSGi入门：动态服务跟踪[译]

2008-06-25T15:13:00.002+08:00

欢迎来到EclipseZone OSGi迷你系列

上回，我们看了如何消费一个服务，使用了一个来自Martin Fowler的启发：一个MovieLister依赖在一个MovieFinder上来搜索通过指定目标的电影。我们还看了使用OSGi服务的动态性质的应对策略，如果它不能找到MovieFinder的一个实例该做什么。

这是另一个我们上次没有考虑的：如果存在有一个以上的有效MovieFinder怎么办？之后任何Bundle可以注册一个服务在MovieFinder接口下，并且所有的Bundle在Registry的眼中都是平等的。

我们能简单的忽略此问题，并且事实是我们的代码上次做了什么。通过在ServiceTracker上调用getService()方法，我们获得了通过ServiceRegistry选择的一个任意的MovieFinder的单独实例。有各种方式影响判断（例如一个SERVICE_RANKING属性可以在ServiceRegistration中被指定），但是正如一个消费者，我们将在这个判断上从来没有完全的控制。事实上没有太多的控制是一件好事——终究我们真正能使用所有MovieFinder的实例。这是使用在第一个位置点的接口。

或者，它可能在某些时候觉得使用多个服务实例。例如，如果有多个MovieFinder服务有效，可能意味着有多个电影数据的来源供MovieLister使用。当处理一个电影搜索时通过使用所有的服务，我们可以转换为更宽广的网络并为用户提供更好的搜索结果。

另一个变化，我们回到上次讨论的问题：当没有可用的MovieFinder服务存在的时候我们应该做什么？我们简单的返回null不论何时调用listByDirector()方法并且MovieFinder是不可用的。But what if we made it impossible for methods on MovieLister to be called when the MovieFinder isn't present?

MovieLister是一个服务，就像MovieFinder。如果MovieFinder消失了，如何让MovieLister消失？换句话说，我们想要MovieLister服务有个一对多的依赖在MovieFinder上。在指导的上个部分，我们有个0..1的依赖。

让我们对MovieListerImpl做些改变。替换成以下代码：

package osgitut.movies.impl;

import java.util.*;

import osgitut.movies.*;

public class MovieListerImpl implements MovieLister {

private Collection finders =

Collections.synchronizedCollection(new ArrayList());

protected void bindFinder(MovieFinder finder) {

finders.add(finder);

System.out.println("MovieLister: added a finder");

}

protected void unbindFinder(MovieFinder finder) {

finders.remove(finder);

System.out.println("MovieLister: removed a finder");

}

public List listByDirector(String director) {

MovieFinder[] finderArray = (MovieFinder[])

finders.toArray(new MovieFinder[finders.size()]);

List result = new LinkedList();

for(int j=0; j<finderArray.length; j++) {

Movie[] all = finderArray[j].findAll();

for(int i=0; i><all.length; i++) {

if(director.equals(all[i].getDirector())) {

result.add(all[i]);

}

return result;

}

我们事实上已经从MovieListerImpl移除了所有OSGi依赖——它现在是个纯粹的POJO。然而它需要某人或某物去跟踪MovieFinder服务并通过bindFinder()方法提供它们，所以我们创建一个新的文件osgitut/movies/impl/MovieFinderTracker.java来做这个：

package osgitut.movies.impl;

import org.osgi.framework.*;

import org.osgi.util.tracker.*;

import osgitut.movies.*;

public class MovieFinderTracker extends ServiceTracker {

private final MovieListerImpl lister = new MovieListerImpl();

private int finderCount = 0;

private ServiceRegistration registration = null;

public MovieFinderTracker(BundleContext context) {

super(context, MovieFinder.class.getName(), null);

}

private boolean registering = false;

public Object addingService(ServiceReference reference) {

MovieFinder finder = (MovieFinder) context.getService(reference);

lister.bindFinder(finder);

synchronized(this) {

finderCount ++;

if (registering)

return finder;

registering = (finderCount == 1);

if (!registering)

return finder;

}

ServiceRegistration reg = context.registerService(

MovieLister.class.getName(), lister, null);

synchronized(this) {

registering = false;

registration = reg;

}

return finder;

}

public void removedService(ServiceReference reference, Object service) {

MovieFinder finder = (MovieFinder) service;

lister.unbindFinder(finder);

context.ungetService(reference);

ServiceRegistration needsUnregistration = null;

synchronized(this) {

finderCount --;

if (finderCount == 0) {

needsUnregistration = registration;

registration = null;

}

if(needsUnregistration != null) {

needsUnregistration.unregister();

}

这个类覆盖了上次我们谈到的ServiceTracker类，并且制定了当服务来去时ServiceTracker的举动。特别的，当一个MovieFinder被添加了的时候调用addingService()方法，并且当一个MovieFinder被移除了的时候调用removedService()方法。还有一个modifiedService()方法我们可以覆盖，但是我们在这里不需要它。

这里的两个方法值得细看。首先，在addingService()中我们看到传递给我们的参数与其实施记得服务实现对象不如是一个ServiceReference。ServiceReference是一个可以被随意当作参数传递的轻量句柄，并且它能够被用来获取服务的属性，比如那些用ServiceRegistration提供的。关键，获取一个ServiceReference对象不会造成OSGi框架增加目标服务的使用计数。你因此可以认为这类似于Java反射API中的WeakReference类。

第一件事我们在我们的例子中用ServiceReference来获得真实的MovieFinder服务对象。为了做这些我们再次需要BundleContext——记住，所有同OSGi框架的交互都是通过BundleContext接口完成的。很巧的是我们的父类ServiceTracker保持了BundleContext引用在一个叫做context的protected成员字段，这样我们可以一直使用。

下次，我们用上面定义的bindFinder()方法绑定finder到我们的MovieListerImpl，之后我们注册MovieListerImpl成为一个服务，在MovieLister接口的下面。注意，我们要很小心的仅在它没有被注册过的时候注册服务，因为在这个情景中我们想要一个独立的跟踪多个MovieFinder服务的MovieLister。

最终，我们从这个方法返回。这还有另一个点很有趣——addingService的返回类型只是Object，所以我们要返回什么呢？事实上ServiceTracker不关心，我们能返回我们喜欢的任何东西。然而，我们当我们调用modifiedService和/或removedService时返回给我们从addingService返回的对象。所以你看我们的removedService方法的第一行，你可以看到我们立刻转换Object为MovieFinder那样我们就能从lister中解除绑定。然后如果跟踪到的finder变为了0，那么我们注销MovieLister服务。

通常的，我们在addingService中做的任何事都要在removedService方法中销毁。因此我们将从addingService方法返回任何能帮助我们找到它曾做过的任何事。可能是一个HashMap中的键，或者可能是一个ServiceRegistration对象，或者(正如在这个情况中)可能是实际的服务对象。

像removedService中的最后一步，我们需要"unget"我们上次的"got"。这是非常重要的，因为Service Registry因此来减少此服务的使用计数器，那将允许当计数器置为0时释放服务。

现在我们需要一个激活器，osgitut/movies/impl/TrackingMovieListerActivator.java：

package osgitut.movies.impl;

import org.osgi.framework.*;

public class TrackingMovieListerActivator implements BundleActivator {

private MovieFinderTracker tracker;

public void start(BundleContext context) {

tracker = new MovieFinderTracker(context);

tracker.open();

}

public void stop(BundleContext context) {

tracker.close();

}

和一个manifest，TrackingMovieLister.mf：

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: Tracking Movie Lister

Bundle-SymbolicName: TrackingMovieLister

Bundle-Version: 1.0.0

Bundle-Activator: osgitut.movies.impl.TrackingMovieListerActivator

Import-Package: org.osgi.framework,

org.osgi.util.tracker,

osgitut.movies;version="[1.0.0,2.0.0)"

并且，我将脱离它让你像一个联系那样建立和部署这个Bundle到Equinox。这些做完，试试按以下步骤的序列来看看每件事在工作：

引用原文:

1. 启动BasicMovieFinder和启动TrackingMovieLister。检查"MovieLister: added a finder"信息的显示；

2. 输入services命令并检查MovieLister服务已经存在注册；

3. 停止BasicMovieFinder并检查"MovieLister: removed a finder"消息的显示；

4. 再次输入services命令并检查没有MovieLister服务被注册。

到这里我们完成了一项强大技术的播种。我们约束了一个服务的生命周期到另外的服务的生命周期——事实上是多个。进一步发展这个技术，我们能够让其他服务约束到MovieLister，并且仍然是另外的服务依赖在那个上面，等等。我们最终构建了一个相互依赖服务的图表，但是不同于通过一些静态IoC容器构建的Bean的图表，我们图表是可靠的，自我恢复的并能够适应变化的环境。

另一方面，我们写的代码有些问题。MovieFinderTracker和TrackingMovieListerActivator类事实上只是一个模板形式的加载，并且如果我们要开始扩展这个系统之后我们将一遍又一遍的写着相同的代码来获得完美的约束，只是每次有些略微的修改。因此下个部分我们将看到仅仅通过一对XML标记行来替换所有的那些代码。

所以在下个部分我们将停止用命令行工具在一个目录中建立任何东西。在这个指导开始的时候我的目标是展示OSGi是一个简单但仍然强大的框架，并且你无需一个像Eclipse那样强大的，重量级的IDE来开发OSGi Bundle。但一些东西显示的太过简单，总是怀疑IDE释放了一些黑魔法代替我们处理。我希望我展示的不存在这种情况，OSGi不需要黑魔法。另一方面，如果你已经像我一样把任何代码都放到这目录的话，你将开始渴望一个正式的开发环境。我也是。对于OSGi这不是问题，当然——任何Java项目如果像这样仅仅使用标准工具，将会很快的失控。

然而，我恐怕你将要知道EclipseCon之后才能读到下个部分。我将跳上一个飞机在我去往Santa Clara的路上待上不到24小时。希望在那里看到你。

感谢BJ Hargrave为统一代码所建议的更好的解决方案。

参考:

原始文章http://www.eclipsezone.com/eclipse/forums/t91059.rhtml

以下是BJ Hargrave的建议：

At 11:14 AM on Mar 3, 2007, BJ Hargrave wrote:

Re: Getting Started with OSGi: Dynamic Service Tracking

Great example.

In the spirit of being pedantic , I would like to observe that the MovieFinderTracker class is not thread-safe which is important in a ServiceTracker since ServiceEvents are synchronously delivered from potentially numerous threads. The issue is the registration field which is shared mutable state. Reading and writing of this field MUST be protected.

Here is a thread-safe version:

private boolean registering = false;

public Object addingService(ServiceReference reference) {

MovieFinder finder = (MovieFinder) context.getService(reference);

lister.bindFinder(finder);

synchronized(this) {

finderCount ++;

if (registering)

return finder;

registering = (finderCount == 1);

if (!registering)

return finder;

}

ServiceRegistration reg = context.registerService(

MovieLister.class.getName(), lister, null);

synchronized(this) {

registering = false;

registration = reg;

}

return finder;

}

public void removedService(ServiceReference reference, Object service) {

MovieFinder finder = (MovieFinder) service;

lister.unbindFinder(finder);

context.ungetService(reference);

ServiceRegistration needsUnregistration = null;

synchronized(this) {

finderCount --;

if (finderCount == 0) {

needsUnregistration = registration;

registration = null;

}

if(needsUnregistration != null) {

needsUnregistration.unregister();

}

You were also missing the ungetService call in removedService (even though the text mentions the importance of this).

I think your articles are excellent. I just want to make them more accurate!>

[JAVA]OSGi入门：消费一个服务[译]

2008-06-25T15:12:00.005+08:00

在我们的上个部分，我们看了如何注册一个服务。现在哦我们需要从另外的Bundle查找并使用服务。

我们将问题放到我们的需求的上下文中，那个通过Martin Fowler的依赖反转的页面获得的灵感。我们建立了一个MovieFinder的服务并通过Service Registry注册了它。现在我们想要建立使用了MovieFinder的一个MovieLister来搜索定向的电影。我们假定MovieLister它自己将是被其它Bundle消费的一个服务，例如一个GUI应用程序。问题是，OSGi服务是动态的……它们来去都是动态的。意思就是有时我们想要调用MovieFinder服务但是它恰巧无效。

所以，如果MovieFinder没有呈现，那么MovieLister将做什么？显然，通过MovieLister完成工作的重要部分是调用MovieFinder，所以这有一些有用的选择给我们：

[list=decimal]

生成一个错误，例如返回null或者抛出一个异常

等待

在第一次里不要调用
[/list]

在这篇文章中我们将首先看前两项，它们十分简单。第三个选项可能甚至仍然没有什么感觉，但是看过前两个后你将会对它抱有希望。

第一件事我们需要为MovieLister服务定义接口。复制以下代码到osgitut/movies/MovieLister.java文件中：

package osgitut.movies;

import java.util.List;

public interface MovieLister {

List listByDirector(String name);

}

现在创建文件osgitut/movies/impl/MovieListerImpl.java：

package osgitut.movies.impl;

import java.util.*;

import osgitut.movies.*;

import org.osgi.framework.*;

import org.osgi.util.tracker.ServiceTracker;

public class MovieListerImpl implements MovieLister {

private final ServiceTracker finderTrack;

public MovieListerImpl(ServiceTracker finderTrack) {

this.finderTrack = finderTrack;

}

public List listByDirector(String name) {

MovieFinder finder = (MovieFinder) finderTrack.getService();

if(finder == null) {

return null;

} else {

return doSearch(name, finder);

}

private List doSearch(String name, MovieFinder finder) {

Movie[] movies = finder.findAll();

List result = new LinkedList();

for (int i = 0; i < movies.length; i++) {

if(movies[i].getDirector().indexOf(name) > -1) {

result.add(movies[i]);

}

return result;

}

这可能是我们的目前最长的代码样本！那么这里将要做什么？首先你注意搜索电影的实际的逻辑被分隔在doSearch(String, MovieFinder)方法中，来帮助我们隔离OSGi具体代码。偶然的，我们执行搜索的方式是相当的愚笨和低效率，但是这不是这节指导的重点。我们无论如何只有两个电影在数据库中！

有趣的部分是在listByDirector(String name)方法中，使用了一个ServiceTracker对象来从Service Registry中获得MovieFinder。ServiceTracker是将最低级别的OSGi API中的大量令人不愉快的细节抽象出来的非常有用的类。然而我们仍然要检查服务是否确实存在。我们采取在我们的构造函数中传递给我们的ServiceTracker。

注意，你可能见过其他地方的代码从Registry获得一个服务而不使用ServiceTracker。例如，它可能调用BundleContext使用getServiceReference和getService。可是这个代码你不得不写的十分复杂并且它不得不小心的自行清理。以我所见，放到低级别的API中处理的益处很少，并且有很多的问题。总是单独使用ServiceTracker更好。

一个不错的创建ServiceTracker的地方是在Bundler的激活器中。复制这段代码到osgitut/movies/impl/MovieListerActivator.java：

package osgitut.movies.impl;

import java.util.*;

import org.osgi.framework.*;

import org.osgi.util.tracker.ServiceTracker;

import osgitut.movies.*;

public class MovieListerActivator implements BundleActivator {

private ServiceTracker finderTracker;

private ServiceRegistration listerReg;

public void start(BundleContext context) throws Exception {

// Create and open the MovieFinder ServiceTracker

finderTracker = new ServiceTracker(context, MovieFinder.class.getName(), null);

finderTracker.open();

// Create the MovieLister and register as a service

MovieLister lister = new MovieListerImpl(finderTracker);

listerReg = context.registerService(MovieLister.class.getName(), lister, null);

// Execute the sample search

doSampleSearch(lister);

}

public void stop(BundleContext context) throws Exception {

// Unregister the MovieLister service

listerReg.unregister();

// Close the MovieFinder ServiceTracker

finderTracker.close();

}

private void doSampleSearch(MovieLister lister) {

List movies = lister.listByDirector("Miyazaki");

if(movies == null) {

System.err.println("Could not retrieve movie list");

} else {

for (Iterator it = movies.iterator(); it.hasNext();) {

Movie movie = (Movie) it.next();

System.out.println("Title: " + movie.getTitle());

}

现在来看看这个激活器的启动。首先，在start方法中它创建了一个ServiceTracker对象，在我们刚写的MovieLister中使用。然后"打开"ServiceTracker告诉它启动跟踪Registry中MovieFinder服务的实例。之后，创建我们的MovieListerImpl对象并在Registry注册它到名为"MovieLister"的接口下。最后，为了在我们启动Bundle时看到有意思的事情，激活器靠MovieLister运行了一个简单的搜索并打印出结果。

我们需要建立并安装这个Bundle。我这次将不给出完整的介绍——你可以复习一下上个部分并使它工作。记得你需要创建一个manifest文件，并且它指示osgitut.movies.impl.MovieListerActivator类为Bundle-Activator。并且Import-Package行需要包含三个包，名称是org.osgi.framework，org.osgi.util.tracker和osgitut.movies。

一旦你已经安装了MovieLister.jar到Equinox运行时，你可以启动它。在那点上你将看到两条信息中的一条，依赖于是否这个BasicMovieFinder的Bundle在上一次一直在运行。如果它没有运行，你将看到：

1 2	osgi> start 2 Could not retrieve movie list

但是如果它正在运行你将看到：

1 2	osgi> start 2 Title: Spirited Away

通过停止和启动各个Bundle，你将能够显示任一信息。并且那些几乎是这部分的全部，除了记得我说过当一个服务无效时等待的事情？代码我们已经有了，这实际上是很琐碎的：简单的改变MovieListerImpl的16行来调用waitForService(5000)在ServiceTracker上代替getService()，并且添加try/catch块来捕捉InterruptedException。

listByDirector()方法等待5000毫秒的原因是要等MovieFinder服务被显示出来。如果一个MovieFinder服务那时已经安装了，当然，如果它已经存在——我们将立即获得它来使用。

通常，我们建议不要像这样挂起线程。特别在这种情况下，它可能很危险因为listByDirector()方法实际是从我们的Bundle激活器的start方法调用的，这是一个从框架线程调用的方法。
激活器意味着要迅速地返回，因为当一个Bundle启动了的时候会有一定数量的其它事情。事实上最坏的情况下我们可能引起死锁，因为我们会进入一个在属于框架对象的synchronized块，那可能已经被其他的一些给锁定了。通常的做法是从不在Bundle激活器的start方法中处理任何长时间运行或者阻塞操作，或者在框架直接调用的代码不做任何操作。

在下个部分中，我们将看看在使用应付神奇的第三个选项："Don't exist in the first place"。稍候！

参考:
原始文章http://www.eclipsezone.com/eclipse/forums/t90796.html

[JAVA]OSGi入门：注册一个服务[译]

2008-06-25T15:12:00.004+08:00

欢迎回来EclipseZone OSGi迷你系列。终于，我们准备接触Services了。我认为，Service层是OSGi最精彩的部分，所以接下来的部分将会很有趣。

上一次我们看了MovieFinder接口的例子，我们讲了将使用MovieLister搜索影片。事实上你可以认为这个例子——它从Martin Fowler的著名页上的"依赖注入"，也正如所知道的"反转控制"(Inversion of Control)或IoC。

重新用IoC来尝试解决这个问题。一个MovieLister并不特别关心原始电影数据的出处，所以我们使用MovieFinder接口来从它隐藏细节。思想是我们可以代替MovieFinder的任一细节，比如获取数据库或者甚至调用一个Amazon Web Service，既MoiveLister仅仅依赖于这个接口，不是任意具体实现。

到目前为止一切顺利，但是在一些点上，我们必须确实给一个具体的MovieFinder到MovieLister的实现。与其让MovieLister到外面去调用一个查找方法，不如我们用一个外部的容器"推"一个合适的对象给它。因此这个成为反转控制。不少这样的容器已经被开发出来了，例如PicoContainer，HiveMind，Spring甚至是EJB3.0。可是所有这些容器都有一个限制：它们大多是静态的。一旦一个MovieFinder给予了一个MovieLister，它就相当于JVM的生命期。

OSGi也允许我们实现IoC模式，但是在动态方法中。它可能动态的提供MovieFinder的实现给MovieLister并在之后移除它们。接下来，我们能够做到在一个文本文件查找电影的应用程序到使用Amazon Web Services的查找它们的热交换。

这就是服务层帮我们做的。十分简单，我们注册一个MovieFinder服务到Service Regisgry中。之后MovieLister可以用那个MovieFinder服务被提供出来。一个服务因此不比一个Java对象——POJO多些什么——并且它被注册在Java接口的名称下面（一个POJI？）。

这次，我们将这是看看使用registry来注册服务。稍后，我们看看如何获得这个registry外的服务并提供一个MovieLister。

我们将添加上次我们建立的BasicMovieFinder的Bundle。我们不需要修改已存在的类，我们仅仅需要添加一个Bundle的激活器。所以复制以下代码到osgitut/movies/impl/BasicMovieFinderActivator.java文件中：

package osgitut.movies.impl;

import org.osgi.framework.*;

import osgitut.movies.*;

import java.util.Properties;

import java.util.Dictionary;

public class BasicMovieFinderActivator implements BundleActivator {

private ServiceRegistration registration;

public void start(BundleContext context) {

MovieFinder finder = new BasicMovieFinderImpl();

Dictionary props = new Properties();

props.put("category", "misc");

registration = context.registerService(

MovieFinder.class.getName(),

finder, props);

}

public void stop(BundleContext context) {

registration.unregister();

}

现在替换BasicMovieFinder.mf的内容：

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: Basic Movie Finder

Bundle-SymbolicName: BasicMovieFinder

Bundle-Version: 1.0.0

Bundle-Activator: osgitut.movies.impl.BasicMovieFinderActivator

Import-Package: org.osgi.framework,

osgitut.movies;version="[1.0.0,2.0.0)"

自从上一次以来，有两个信息被添加到这个manifest。第一个是Bundle-Activator行，它告诉框架关于我们的Bundle的新激活器——我们上次没有用到它。同样，我添加了org.osgi.framework到这个导入到包。正如我们的Bundle的上版本不能同框架交互，它不需要导入这个OSGi API包。

现在你可以重新建立BasicMovieFinder.jar文件：

1 2	> javac -classpath equinox.jar:MoviesInterface.jar osgitut/movies/impl/.java > jar cfm BasicMovieFinder.jar BasicMovieFinder.mf osgitut/movies/impl/.class

回到OSGi控制台，你将看到上次的BasicMovieFinder.jar仍然被安装着。那么你只需要通过输入update N来告诉OSGi去更新这个Bundle，这个N是Bundle的数字标识（你用ss命令找到的那个）。现在使用start N来启动Bundle并且你会看见……很小的事情发生了。

事实上，我们仅仅用OSGi Service Registry注册了我们第一个服务，但是可惜的是没有人在"另一端"，所以这个注册不能产生任何可视化的影响。如果我们想要亲自保证我们的代码实际做了些什么，我们将继续挖掘，并且我们可以使用以下命令：

1	services (objectClass=*MovieFinder)

我们将看到以下输出：

{osgitut.movies.MovieFinder}={category=misc, service.id=22}

Registered by bundle: file:BasicMovieFinder.jar [4]

No bundles using service.

很好，我们的服务被注册了，并且我很想继续告诉你如何查找服务并在其他的Bundle中使用它，但是那将在另外一天了。在这期间，看看你可以用services命令做些什么。开始时常是输入没有任何表达式的services，之后——那确实可以通过服务的过滤仅仅显示器中的一个。不使用过滤，你将看到所有的注册了的服务。有着令人惊讶的巨大数字。

参考:

原始文章http://eclipsezone.com/eclipse/forums/t90688.html