OSGi 联盟 是一个独立组织，负责定义 OSGi 服务版本 4 的功能。OSGi 服务平台是一组开放规格，简化了复杂软件应用程序的构建、部署和管理。

OSGi 技术通常被称为 Java 的动态模块系统。OSGi 是 Java 的框架，它使用捆绑程序以模块化方式部署 Java 组件，并处理依赖项、版本控制、类路径控制和类加载。OSGi 的生命周期管理允许您在不关闭 JVM 的情况下加载、启动和停止捆绑包。

OSGi 为 Java、卓越的类加载架构和 registry 为服务提供最佳运行时平台。捆绑包可以导出服务、运行进程，并且其依赖项管理。每个捆绑包都可以满足由 OSGi 容器管理的要求。

Fuse 使用 Apache Felix 作为其默认的 OSGi 实施。框架层组成了安装捆绑包的容器。框架以动态、可扩展的方式管理捆绑包的安装和更新，并管理捆绑包和服务之间的依赖项。

OSGi 框架包含以下内容：

框架中的每个层都取决于它下的层。例如，生命周期层需要模块层。模块层可以在没有生命周期和服务层的情况下使用。

OSGi 服务是 Java 类或服务接口，其服务属性定义为名称/值对。服务属性区分通过同一服务接口提供服务的服务供应商。

OSGi 服务由服务界面定义，它作为服务对象实施。服务的功能由它实施的接口定义。因此，不同的应用程序可以实施相同的服务。

服务接口允许捆绑包通过绑定接口而不是实现来交互。服务接口应尽可能使用几个实施详情来指定。

在 OSGi 框架中，服务层使用发布、查找和绑定服务模型提供 第 1.5 节 “OSGi 捆绑包” 及其包含组件之间的通信。该服务层包含一个服务 registry，其中：

服务归捆绑包所有，并在其内运行。捆绑包在一个或多个 Java 接口下将服务的实施注册到框架服务 registry。因此，服务的功能可供框架控制下的其他捆绑包使用，其他捆绑包可以查找和使用该服务。lookup 使用 Java 接口和服务属性来执行。

每个捆绑包都可以使用其接口及其属性的完全限定名称在服务 registry 中注册多个服务。捆绑包使用带有 LDAP 语法的名称和属性来查询服务 registry。

捆绑包负责运行时服务依赖项管理活动，包括发布、发现和绑定。捆绑包也可以适应绑定捆绑包的服务的动态可用性(arrival 或 departure)生成的更改。

您可以直接从安装的 bin 子目录启动 Karaf 运行时，而无需修改您的环境。但是，如果您要在其他文件夹中启动它，您需要将 Karaf 安装的 bin 目录添加到 PATH 环境变量中，如下所示：

Windows

set PATH=%PATH%;InstallDir\bin

Linux/UNIX

export PATH=$PATH,InstallDir/bin`

如果您要从安装目录启动 Karaf 运行时，请使用以下命令：

Windows

bin\fuse.bat

Linux/UNIX

./bin/fuse

如果 Karaf 正确启动，您应该在控制台中看到以下内容：

Red Hat Fuse starting up. Press Enter to open the shell now...
100% [========================================================================]

Karaf started in 8s. Bundle stats: 220 active, 220 total

 ____          _   _   _       _     _____
|  _ \ ___  __| | | | | | __ _| |_  |  ___|   _ ___  ___
| |_) / _ \/ _` | | |_| |/ _` | __| | |_ | | | / __|/ _ \
|  _ <  __/ (_| | |  _  | (_| | |_  |  _|| |_| \__ \  __/
|_| \_\___|\__,_| |_| |_|\__,_|\__| |_|   \__,_|___/___|

  Fuse (7.x.x.fuse-xxxxxx-redhat-xxxxx)
  http://www.redhat.com/products/jbossenterprisemiddleware/fuse/

Hit '<tab>' for a list of available commands
and '[cmd] --help' for help on a specific command.

Open a browser to http://localhost:8181/hawtio to access the management console

Hit '<ctrl-d>' or 'shutdown' to shutdown Red Hat Fuse.

karaf@root()>

在服务器模式中启动 会在后台运行 Apache Karaf，无需本地控制台。然后，您将使用远程控制台连接到正在运行的实例。详情请查看 第 16.2 节 “远程连接和断开连接”。

若要在服务器模式中启动 Karaf，请运行以下命令

Windows

bin\start.bat

Linux/UNIX

./bin/start

在生产环境中，您可能想让运行时实例只能通过本地控制台访问。换句话说，您无法通过 SSH 控制台端口远程连接到运行时。您可以通过在客户端模式中启动运行时来完成此操作：

Windows

bin\fuse.bat client

Linux/UNIX

./bin/fuse client

在调试模式下运行 Fuse 有助于更有效地识别和解决错误。默认禁用这个选项。启用后，Fuse 在端口 5005 上启动 JDWP 套接字。

您有三种 在调试模式下运行 Fuse 的方法。

$ export KARAF_DEBUG=1
$ bin/start

$ bin/fuse debug

$ bin/fuse debugs

如果您通过运行 fuse 或 fuse 客户端 启动 Karaf 实例，您可以在 karaf > 提示符下执行以下操作之一来停止它：

您可以通过调用 InstallDir/bin 目录中的 stop (.bat) 来停止本地运行 Karaf 实例(root 容器)，如下所示：

Windows

bin\stop.bat

Linux/UNIX

./bin/stop

Karaf stop 脚本调用的关闭机制与 Apache Tomcat 中实施的关闭机制类似。Karaf 服务器打开专用关闭端口（与 SSH 端口相同），以接收关闭通知。默认情况下，会随机选择关闭端口，但如果您愿意，您可以将它配置为使用特定端口。

您可以通过在 InstallDir/etc/config.properties 文件中设置以下属性来自定义关闭端口：

您可以停止在远程主机上运行的容器实例，如 第 16.3 节 “停止远程容器” 所述。

默认情况下，Apache Karaf 运行时会防止网络攻击，因为其所有公开端口都需要用户身份验证，并且最初没有定义任何用户。换句话说，默认远程无法访问 Apache Karaf 运行时。

如果要远程访问运行时，您必须首先自定义安全配置，如下所述。

如果要启用对 Karaf 容器的远程访问，您必须在启动容器前创建一个安全 JAAS 用户：

默认情况下，没有为容器定义 JAAS 用户，这样可有效地禁用远程访问（无法登录）。

要创建安全 JAAS 用户，请编辑 InstallDir/etc/users.properties 文件并添加一个新的 user 字段，如下所示：

Username=Password,admin

其中 Username 和 Password 是新用户凭证。admin 角色授予此用户访问容器的所有管理和管理功能的特权。

不要定义带有前导 0 的数字用户名。此类用户名总是会导致登录尝试失败。这是因为，当输入显示为数字时，控制台使用的 Karaf shell 会丢弃前导零。例如：

karaf@root> echo 0123
123
karaf@root> echo 00.123
0.123
karaf@root>

Karaf 容器支持基于角色的访问控制，规范通过 JMX 协议、Karaf 命令控制台和 Fuse 管理控制台的访问。当为用户分配角色时，您可以从标准角色集合中选择，这提供了 表 3.1 “访问控制的标准角色” 中描述的访问级别。

有关基于角色的访问控制的详情，请参阅基于角色的访问控制。

容器公开以下端口：

当满足以下任一条件时，您可以访问远程控制台端口：

例如，要从运行容器的同一机器登录到远程控制台端口，请输入以下命令：

./client -u Username -p Password

其中 Username 和 Password 是带有 ssh 角色的 JAAS 用户的凭据。通过远程端口访问 Karaf 控制台时，您的特权取决于分配给用户在 etc/users.properties 文件中的角色。如果要访问完整的控制台命令集合，用户帐户必须具有 admin 角色。

您可以使用以下措施在远程控制台端口上增强安全性：

JMX 端口默认是启用的，并由 JAAS 身份验证进行保护。要访问 JMX 端口，您必须已经使用至少一组登录凭据配置了 JAAS。要连接到 JMX 端口，请打开 JMX 客户端（如 jconsole）并连接到以下 JMX URI：

service:jmx:rmi:///jndi/rmi://localhost:1099/karaf-root

您还必须为 JMX 客户端提供有效的 JAAS 凭据才能连接。

Fuse 控制台已经由 JAAS 身份验证保护。要添加 SSL 安全性，请参阅 保护 Undertow HTTP 服务器。

为了帮助您快速开始，您可以调用 Maven archetype 来生成 Maven 项目的初始概述(Maven archetype 与项目向导类似)。以下 Maven archetype 生成用于构建 OSGi 捆绑包的项目。

Apache Camelosgi archetype 创建一个项目，用于构建可部署到 OSGi 容器中的路由。要使用协调、GroupId:ArtifactId:Version 生成 Maven 项目，请输入以下命令：

mvn archetype:generate \
  -DarchetypeGroupId=org.apache.camel.archetypes \
  -DarchetypeArtifactId=camel-archetype-blueprint \
  -DarchetypeVersion=${current-Camel-version} \
  -DgroupId=GroupId \
  -DartifactId=ArtifactId \
  -Dversion=Version

默认情况下，前面的 archetypes 在新目录中创建一个项目，其名称与指定的工件 ID ArtifactId 相同。要构建由新项目定义的捆绑包，请打开命令提示符，进入项目目录（即包含 pom.xml 文件的目录），并输入以下 Maven 命令：

mvn install

此命令的效果是编译所有 Java 源文件，以在 ArtifactId/target 目录下生成捆绑包 JAR，然后在本地 Maven 存储库中安装生成的 JAR。

如果您已经有一个 Maven 项目，且您想要修改它以便生成 OSGi 捆绑包，请执行以下步骤：

通过将软件包类型改为项目的 pom.xml 文件中的 捆绑包，将 Maven 配置为生成 OSGi 捆绑包。将 packaging 元素的内容改为 捆绑包，如下例所示：

<project ... >
  ...
  <packaging>bundle</packaging>
  ...
</project>

此设置的影响是选择 Maven 捆绑包插件 maven-bundle-plugin，以执行此项目的打包。但是，除非将捆绑包插件明确添加到 POM 中，此设置本身不会起作用。

要添加 Maven 捆绑包插件，请将以下示例 插件 元素复制并粘贴到项目的 pom.xml 文件的 project/build/plugins 部分：

<project ... >
  ...
  <build>
    <defaultGoal>install</defaultGoal>
    <plugins>
      ...
    <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <version>3.3.0</version>
        <extensions>true</extensions>
        <configuration>
          <instructions>
            <Bundle-SymbolicName>${project.groupId}.${project.artifactId}
            </Bundle-SymbolicName>
            <Import-Package>*</Import-Package>
          </instructions>
        </configuration>
      </plugin>
    </plugins>
  </build>
  ...
</project>

其中，捆绑包插件由 instructions 元素中的设置进行配置。

有关为 Apache CXF 配置捆绑包插件的一些特定建议，请参考 第 5.3 节 “在捆绑包中打包 Web 服务”。

几乎需要在 POM 文件中指定 JDK 版本。如果您的代码使用 Java 语言的任何现代功能，如通用、静态导入等，且您已在 POM 中自定义 JDK 版本，则 Maven 将无法编译源代码。将 JAVA_HOME 和 PATH 环境变量设置为 JDK 的正确值不足，还必须修改 POM 文件。

要配置 POM 文件，以便它接受 JDK 1.8 中引入的 Java 语言功能，请在 POM 中添加以下 maven-compiler-plugin 插件设置（如果它们尚不存在）：

<project ... >
  ...
  <build>
    <defaultGoal>install</defaultGoal>
    <plugins>
      ...
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
  ...
</project>

本节介绍如何为 Apache CXF 应用程序修改现有 Maven 项目，以便项目生成适合在 Red Hat Fuse OSGi 容器中部署的 OSGi 捆绑包。要转换 Maven 项目，您需要修改项目的 POM 文件和项目的 Blueprint 文件（位于 META-INF/spring中）。

要配置 Maven POM 文件来生成捆绑包，基本上有两个更改，您需要进行两个更改：将 POM 的软件包类型改为 bundle; 并将 Maven 捆绑包插件添加到 POM 中。详情请查看 第 5.1 节 “生成捆绑包项目”。

为了让应用程序使用 Apache CXF 组件，您需要将其软件包导入到应用程序的捆绑包中。由于 Apache CXF 中依赖项的复杂性质，您无法依赖 Maven 捆绑包插件或 bnd 工具来自动确定所需的导入。您需要显式声明它们。

您需要将以下软件包导入到捆绑包中：

javax.jws
javax.wsdl
javax.xml.bind
javax.xml.bind.annotation
javax.xml.namespace
javax.xml.ws
org.apache.cxf.bus
org.apache.cxf.bus.spring
org.apache.cxf.bus.resource
org.apache.cxf.configuration.spring
org.apache.cxf.resource
org.apache.cxf.jaxws
org.springframework.beans.factory.config

例 5.1 “配置强制导入软件包” 演示了如何在 POM 中配置 Maven 捆绑包插件来导入强制软件包。必需的导入软件包在 Import-Package 元素中以逗号分隔的列表的形式出现。请注意通配符的外观，即 *，作为列表的最后一个元素。通配符可确保扫描当前捆绑包中的 Java 源文件，以发现需要导入哪些额外软件包。

<project ... >
    ...
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <extensions>true</extensions>
                <configuration>
                    <instructions>
                        ...
                        <Import-Package>
                            javax.jws,
                            javax.wsdl,
                            javax.xml.bind,
                            javax.xml.bind.annotation,
                            javax.xml.namespace,
                            javax.xml.ws,
                            org.apache.cxf.bus,
                            org.apache.cxf.bus.spring,
                            org.apache.cxf.bus.resource,
                            org.apache.cxf.configuration.spring,
                            org.apache.cxf.resource,
                            org.apache.cxf.jaxws,
                            org.springframework.beans.factory.config,
                            *
                        </Import-Package>
                        ...
                    </instructions>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ...
</project>

Web 服务项目通常需要生成代码。Apache CXF 为 JAX-WS 前端提供了两个 Maven 插件，它可让您将代码生成步骤集成到您的构建中。插件选择取决于您是否使用 Java 优先方法或 WSDL 优先方法开发您的服务，如下所示：

OSGi 配置管理服务定义了将配置设置传递给 OSGi 捆绑包的机制。您不必将此服务用于配置，但通常是配置捆绑包应用程序的最便捷方式。蓝图支持 OSGi 配置，可让您使用 OSGi 配置管理服务获得的值替换蓝图文件中的变量。

有关如何使用 OSGi 配置属性的详情，请参考 第 5.3.7 节 “配置捆绑包插件” 和 第 9.6 节 “向该功能添加 OSGi 配置”。

PID 字符串(symbolic-name 语法)允许 OSGI 规格中的连字符。但是，连字符由 Apache Felix.fileinstall 和 config:edit shell 命令解释，以区分"受管服务"和"受管服务工厂"。因此，建议您不要在 PID 字符串中使用连字符。

Fuse 监控 FUSE_HOME/deploy 目录中的文件，并在此目录中热部署所有内容。每次将文件复制到此目录时，该文件都会在运行时安装并启动。然后，您可以更新或删除 FUSE_HOME/deploy 目录中的文件，并且更改会自动处理。

例如，如果您只构建了捆绑包，ProjectDir/target/foo-1.0-SNAPSHOT.jar，您可以通过将其复制到 FUSE_HOME/deploy 目录来进行部署（假设您正在处理 UNIX 平台）：

% cp ProjectDir/target/foo-1.0-SNAPSHOT.jar FUSE_HOME/deploy

您可以通过在 Fuse 控制台中发出命令来手动部署和取消部署捆绑包。

使用 bundle:install 命令，在 OSGi 容器中安装一个或多个捆绑包。这个命令使用以下语法：

bundle:install [-s] [--start] [--help] UrlList

其中 UrlList 是空格分开的 URL 列表，用于指定要部署的每个捆绑包的位置。支持以下命令参数：

例如，要安装并启动捆绑包，ProjectDir/target/foo-1.0-SNAPSHOT.jar，请在 Karaf 控制台提示符处输入以下命令：

bundle:install -s file:ProjectDir/target/foo-1.0-SNAPSHOT.jar

要卸载捆绑包，您必须首先使用 bundle:list 命令获取其捆绑包 ID。然后，您可以使用 bundle:uninstall 命令卸载捆绑包（使用捆绑包 ID 作为其参数）。

例如，如果您已安装名为 A Camel OSGi 服务单元 的捆绑包，在控制台提示符下输入 bundle:list 可能会生成类似如下的输出：

...
[ 181] [Resolved   ] [            ] [       ] [   60] A Camel OSGi Service Unit (1.0.0.SNAPSHOT)

现在，您可以输入以下 console 命令，使用 ID 181 卸载捆绑包：

bundle:uninstall 181

当指定 bundle:install 命令的位置 URL 时，您可以使用 Fuse 支持的任何 URL 方案，其中包括以下方案类型：

本质上，通过向特殊的 XML 文件（称为 功能 存储库）添加新的功能元素来创建功能。要创建功能，请执行以下步骤：

OSGI-INF/blueprint

在此目录中带有后缀 .xml 的任何文件都解释为 Blueprint 配置文件；换句话说，任何与模式匹配的文件，OSGI -INF/blueprintAttr.xml。

ProjectDir/src/main/resources/OSGI-INF/blueprint

http://www.osgi.org/xmlns/blueprint/v1.0.0

Blueprint 配置的根元素是 蓝图 XML 配置文件，因此蓝图 XML 配置文件通常具有以下概述形式：

<?xml version="1.0" encoding="UTF-8"?>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
  ...
</blueprint>

Bundle-Blueprint: lib/account.xml, security.bp, cnf/*.xml

通常，在蓝图容器初始化时，它会通过 宽限期，这时尝试解析所有强制依赖项。如果此时无法解决强制依赖项（默认超时为 5 分钟），则容器初始化将中止，且捆绑包没有启动。以下设置可以附加到 Bundle-SymbolicName 清单标头中，以配置宽限期：

例如，要启用 10 秒的宽限期，您可以在清单文件中定义以下 Bundle-SymbolicName 标头：

Bundle-SymbolicName: org.fusesource.example.osgi-client;
 blueprint.graceperiod:=true;
 blueprint.timeout:= 10000

Bundle-SymbolicName 标头的值是分号分隔的列表，其中第一个项是实际捆绑包符号名称，第二个项是 blueprint.graceperiod:=true，启用宽限期和第三个项目 blueprint.timeout:= 10000，指定 10 秒超时。

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">

  <bean id="label" class="java.lang.String">
    <argument value="LABEL_VALUE"/>
  </bean>

  <bean id="myList" class="java.util.ArrayList">
    <argument type="int" value="10"/>
  </bean>

  <bean id="account" class="org.fusesource.example.Account">
    <property name="accountName" value="john.doe"/>
    <property name="balance" value="10000"/>
  </bean>

</blueprint>

其中，最后一个 bean 示例引用的 Account 类可以定义如下：

package org.fusesource.example;

public class Account
{
    private String accountName;
    private int balance;

    public Account () { }

    public void setAccountName(String name) {
        this.accountName = name;
    }

    public void setBalance(int bal) {
        this.balance = bal;
    }
    ...
}

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
    xmlns:ext="http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.2.0">

    <ext:property-placeholder>
      <ext:location>file:etc/ldap.properties</ext:location>
    </ext:property-placeholder>
    ...
    <bean ...>
        <property name="myProperty" value="${myProperty}" />
    </bean>
</blueprint>

属性拥有者配置选项 的规格可在 http://aries.apache.org/schemas/blueprint-ext/blueprint-ext.xsd 中找到。

本节介绍如何在 OSGi 容器中生成、构建和部署简单的 OSGi 服务。该服务是一个简单的 Hello World Java 类，而 OSGi 配置是使用 Blueprint 配置文件定义的。

要使用 Maven Quickstart archetype 生成项目，您必须满足以下先决条件：

maven-archetype-quickstart archetype 创建一个通用 Maven 项目，然后您可以针对您想要的任何目的进行自定义。要使用协调( org.fusesource.example:osgi-service )生成 Maven 项目，请输入以下命令：

mvn archetype:create
-DarchetypeArtifactId=maven-archetype-quickstart
-DgroupId=org.fusesource.example
-DartifactId=osgi-service

此命令的结果是一个目录 ProjectDir/osgi-service，其中包含生成的项目的文件。

您必须自定义 POM 文件来生成 OSGi 捆绑包，如下所示：

创建 ProjectDir/osgi-service/src/main/java/org/fusesource/example/service 子目录。在这个目录中，使用您首选的文本编辑器创建文件 HelloWorldSvc.java，并将代码从 例 12.3 “The HelloWorldSvc Interface” 添加到其中。

package org.fusesource.example.service;

public interface HelloWorldSvc
{
    public void sayHello();
}

创建 ProjectDir/osgi-service/src/main/java/org/fusesource/example/service/impl 子目录。在这个目录中，使用您首选的文本编辑器创建文件 HelloWorldSvcImpl.java，并将代码从 例 12.4 “HelloWorldSvcImpl 类” 添加到该文件中。

package org.fusesource.example.service.impl;

import org.fusesource.example.service.HelloWorldSvc;

public class HelloWorldSvcImpl implements HelloWorldSvc {

    public void sayHello()
    {
        System.out.println( "Hello World!" );
    }

}

Blueprint 配置文件是在类路径上的 OSGI-INF/blueprint 目录下存储的 XML 文件。要在项目中添加 Blueprint 文件，首先创建以下子目录：

ProjectDir/osgi-service/src/main/resources
ProjectDir/osgi-service/src/main/resources/OSGI-INF
ProjectDir/osgi-service/src/main/resources/OSGI-INF/blueprint

其中 src/main/resources 是所有 JAR 资源的标准 Maven 位置。此目录下的资源文件将自动打包到生成的捆绑包 JAR 的根目录范围内。

例 12.5 “用于导出服务的蓝图文件” 显示一个示例 Blueprint 文件，它会创建一个 HelloWorldSvc bean，使用 bean 元素，然后使用 service 元素将 bean 导出为 OSGi 服务。

在 ProjectDir/osgi-service/src/main/resources/OSGI-INF/blueprint 目录下，使用您首选的文本编辑器创建文件 config.xml，并添加来自 例 12.5 “用于导出服务的蓝图文件” 的 XML 代码。

<?xml version="1.0" encoding="UTF-8"?>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">

  <bean id="hello" class="org.fusesource.example.service.impl.HelloWorldSvcImpl"/>

  <service ref="hello" interface="org.fusesource.example.service.HelloWorldSvc"/>

</blueprint>

要安装并运行 osgi-service 项目，请执行以下步骤：

本节介绍如何在 OSGi 容器中生成、构建和部署简单的 OSGi 客户端。客户端在 OSGi 注册表中找到简单的 Hello World 服务，并在其上调用 sayHello （） 方法。

要使用 Maven Quickstart archetype 生成项目，您必须满足以下先决条件：

maven-archetype-quickstart archetype 创建一个通用 Maven 项目，然后您可以针对您想要的任何目的进行自定义。要使用协调( org.fusesource.example:osgi-client )生成 Maven 项目，请输入以下命令：

mvn archetype:create
-DarchetypeArtifactId=maven-archetype-quickstart
-DgroupId=org.fusesource.example
-DartifactId=osgi-client

此命令的结果是一个目录 ProjectDir/osgi-client，包含所生成的项目的文件。

您必须自定义 POM 文件来生成 OSGi 捆绑包，如下所示：

要在客户端项目中添加 Blueprint 文件，首先创建以下子目录：

ProjectDir/osgi-client/src/main/resources
ProjectDir/osgi-client/src/main/resources/OSGI-INF
ProjectDir/osgi-client/src/main/resources/OSGI-INF/blueprint

在 ProjectDir/osgi-client/src/main/resources/OSGI-INF/blueprint 目录下，使用您首选的文本编辑器创建文件 config.xml，并添加来自 例 12.6 “用于导入服务的蓝图文件” 的 XML 代码。

<?xml version="1.0" encoding="UTF-8"?>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">

  <reference id="helloWorld"
        interface="org.fusesource.example.service.HelloWorldSvc"/>

  <bean id="client"
        class="org.fusesource.example.client.Client"
        init-method="init">
    <property name="helloWorldSvc" ref="helloWorld"/>
  </bean>

</blueprint>

其中 reference 元素会创建一个参考管理器，它在 OSGi 注册表中找到 HelloWorldSvc 类型的服务。bean 元素创建 Client 类的实例，注入作为 bean 属性 helloWorldSvc 的服务引用。此外，init-method 属性指定在 bean 初始化阶段调用 Client.init （） 方法（即，服务引用注入客户端 bean 后 ）。

在 ProjectDir/osgi-client/src/main/java/org/fusesource/example/client 目录下，使用您首选的文本编辑器创建文件 Client.java，并添加来自 例 12.7 “客户端类” 的 Java 代码。

package org.fusesource.example.client;

import org.fusesource.example.service.HelloWorldSvc;

public class Client {
    HelloWorldSvc helloWorldSvc;

    // Bean properties
    public HelloWorldSvc getHelloWorldSvc() {
        return helloWorldSvc;
    }

    public void setHelloWorldSvc(HelloWorldSvc helloWorldSvc) {
        this.helloWorldSvc = helloWorldSvc;
    }

    public void init() {
        System.out.println("OSGi client started.");
        if (helloWorldSvc != null) {
            System.out.println("Calling sayHello()");
            helloWorldSvc.sayHello();  // Invoke the OSGi service!
        }
    }

}

Client 类定义 getter 和 setter 方法，用于 helloWorldSvc bean 属性，它允许它通过注入来接收对 Hello World 服务的引用。init （） 方法在 bean 初始化阶段调用，在属性注入后调用，这意味着通常在此方法范围内调用 Hello World 服务。

要安装并运行 osgi-client 项目，请执行以下步骤：

Apache Camel 提供了使用 Bean 语言调用 OSGi 服务的简单方法。当 Apache Camel 应用程序部署到 OSGi 容器中且不需要特殊配置时，此功能会自动可用。

当 Apache Camel 路由部署到 OSGi 容器中时，CamelContext 会自动设置用于解析 bean 实例的 registry 链：registry 链由 OSGi 注册表组成，后跟 Blueprint registry。现在，如果您尝试引用特定的 bean 类或 bean 实例，registry 会解析 bean，如下所示：

考虑由以下 Java 接口定义的 OSGi 服务，它定义了单一方法 getGreeting （） ：

package org.fusesource.example.hello.boston;

public interface HelloBoston {
    public String getGreeting();
}

在定义实现 HelloBoston OSGi 服务的捆绑包时，您可以使用以下 Blueprint 配置导出服务：

<?xml version="1.0" encoding="UTF-8"?>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">

  <bean id="hello" class="org.fusesource.example.hello.boston.HelloBostonImpl"/>

  <service ref="hello" interface="org.fusesource.example.hello.boston.HelloBoston"/>

</blueprint>

假设 HelloBoston 接口由 HelloBostonImpl 类（未显示）实现。

部署包含 HelloBoston OSGi 服务的捆绑包后，您可以使用 Java DSL 从 Apache Camel 应用程序调用该服务。在 Java DSL 中，您可以通过 Bean 语言调用 OSGi 服务，如下所示：

from("timer:foo?period=5000")
  .bean(org.fusesource.example.hello.boston.HelloBoston.class, "getGreeting")
  .log("The message contains: ${body}")

在 bean 命令中，第一个参数是 OSGi 接口或类，它必须与从 OSGi 服务捆绑包导出的接口匹配。第二个参数是您要调用的 bean 方法的名称。有关 bean 命令语法的详情，请参阅 Apache Camel 开发指南 Bean 集成。

在 XML DSL 中，您还可以使用 Bean 语言调用 HelloBoston OSGi 服务，但语法略有不同。在 XML DSL 中，您可以使用 method 元素通过 Bean 语言调用 OSGi 服务，如下所示：

<beans ...>
  <camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
      <from uri="timer:foo?period=5000"/>
      <setBody>
          <method ref="org.fusesource.example.hello.boston.HelloBoston" method="getGreeting"/>
      </setBody>
      <log message="The message contains: ${body}"/>
    </route>
  </camelContext>
</beans>

文件 URL 的语法为PathName，其中 PathName 是类路径上可用的文件的相对或绝对路径名。提供的 PathName 由 Java 的内置文件 URL 处理程序 解析。因此，PathName 语法受到 Java 路径名称的常用约定：特别是，在 Windows 上，每个反斜杠必须被另一个反斜杠转义或被正斜杠替代。

例如，在 Windows 上考虑 pathname, C:\Projects\camel-bundle\target\foo-1.0-SNAPSHOT.jar。以下示例显示了 Windows 上文件 URL 的正确 替代方案：

file:C:/Projects/camel-bundle/target/foo-1.0-SNAPSHOT.jar
file:C:\\Projects\\camel-bundle\\target\\foo-1.0-SNAPSHOT.jar

以下示例显示了 Windows 上文件 URL 的一些 不正确的 替代方案：

file:C:\Projects\camel-bundle\target\foo-1.0-SNAPSHOT.jar        // WRONG!
file://C:/Projects/camel-bundle/target/foo-1.0-SNAPSHOT.jar      // WRONG!
file://C:\\Projects\\camel-bundle\\target\\foo-1.0-SNAPSHOT.jar  // WRONG!

HTTP URL 有标准语法 http:Host[:Port]/[Path][#AnchorName][?Query]。您还可以使用 https 方案指定安全 HTTP URL。提供的 HTTP URL 由 Java 的内置 HTTP URL 处理程序解析，因此 HTTP URL 的行为是 Java 应用的一般方式。

如果使用 Maven 构建捆绑包，或者您知道特定捆绑包可从 Maven 存储库获得，您可以使用 Mvn 处理程序方案来定位捆绑包。

Mvn URL 的语法如下：

mvn:[repositoryUrl!]groupId/artifactId[/[version][/[packaging][/[classifier]]]]

其中 repositoryUrl （可选）指定 Maven 存储库的 URL。groupId,artifactId,version,packaging , 和 classifier 是标准的 Maven 协调，用于定位 Maven 工件。

当指定 Mvn URL 时，只需要 groupId 和 artifactId 协调。以下示例引用了带有 groupId、org.fusesource.example 的 Maven 捆绑包，以及 artifactId,bundle-demo:

mvn:org.fusesource.example/bundle-demo
mvn:org.fusesource.example/bundle-demo/1.1

当省略了 版本时，如第一个示例所示，默认为 LATEST，它根据可用的 Maven 元数据解析为最新版本。

要在没有指定 打包 或 版本 值的情况下指定 分类器 值，最好在 Mvn URL 中留下差距。同样，如果您要指定没有 version 值的 打包 值。例如：

mvn:groupId/artifactId///classifier
mvn:groupId/artifactId/version//classifier
mvn:groupId/artifactId//packaging/classifier
mvn:groupId/artifactId//packaging

在 Mvn URL 中指定 版本 值时，您可以指定一个版本范围（使用标准 Maven 版本范围语法）来代替简单的版本号。您可以使用方括号[ 和 ]- 表示包含范围和括号( 和 )- 表示专用范围。例如，范围 [1.0.4,2.0） 匹配任何版本 v，它满足 1.0.4 categories v < 2.0。您可以在 Mvn URL 中使用这个版本范围，如下所示：

mvn:org.fusesource.example/bundle-demo/[1.0.4,2.0)

首次使用 Mvn URL 之前，您可能需要自定义 Mvn URL 处理程序设置，如下所示：

Mvn URL 处理程序解析对本地 Maven 存储库的引用，并维护远程 Maven 存储库列表。解析 Mvn URL 时，处理程序会首先搜索本地存储库，然后搜索远程存储库以查找指定的 Maven 模版。如果解析 Mvn URL 存在问题，您应该首先检查处理器设置，以查看处理器设置以查看它用于解析 URL 的本地存储库和远程存储库。

要检查 Mvn URL 设置，请在控制台中输入以下命令：

JBossFuse:karaf@root> config:edit org.ops4j.pax.url.mvn
JBossFuse:karaf@root> config:proplist

config:edit 命令将 config:edit 命令的重点切换到属于 org.ops4j.pax.url.mvn persistent ID 的属性。config:proplist 命令输出当前持久性 ID 的所有属性设置。对于 org.ops4j.pax.url.mvn，您应该会看到类似如下的列表：

   org.ops4j.pax.url.mvn.defaultRepositories = file:/path/to/JBossFuse/jboss-fuse-7.5.0.fuse-750035-redhat-00001/system@snapshots@id=karaf.system,file:/home/userid/.m2/repository@snapshots@id=local,file:/path/to/JBossFuse/jboss-fuse-7.5.0.fuse-750035-redhat-00001/local-repo@snapshots@id=karaf.local-repo,file:/path/to/JBossFuse/jboss-fuse-7.5.0.fuse-750035-redhat-00001/system@snapshots@id=child.karaf.system
   org.ops4j.pax.url.mvn.globalChecksumPolicy = warn
   org.ops4j.pax.url.mvn.globalUpdatePolicy = daily
   org.ops4j.pax.url.mvn.localRepository = /path/to/JBossFuse/jboss-fuse-7.5.0.fuse-750035-redhat-00001/data/repository
   org.ops4j.pax.url.mvn.repositories = http://repo1.maven.org/maven2@id=maven.central.repo, https://maven.repository.redhat.com/ga@id=redhat.ga.repo, https://maven.repository.redhat.com/earlyaccess/all@id=redhat.ea.repo, https://repository.jboss.org/nexus/content/groups/ea@id=fuseearlyaccess
   org.ops4j.pax.url.mvn.settings = /path/to/jboss-fuse-7.5.0.fuse-750035-redhat-00001/etc/maven-settings.xml
   org.ops4j.pax.url.mvn.useFallbackRepositories = false
   service.pid = org.ops4j.pax.url.mvn

其中 localRepository 设置显示处理器当前使用的本地存储库位置，而 存储库 设置则显示处理程序当前使用的远程存储库列表。

要自定义 Mvn URL 处理程序的属性设置，请编辑以下配置文件：

InstallDir/etc/org.ops4j.pax.url.mvn.cfg

此文件中的设置允许您指定本地 Maven 存储库的位置、删除 Maven 存储库、Maven 代理服务器设置等。有关这些设置的详情，请查看配置文件中的注释。

特别是，如果您的本地 Maven 存储库位于非默认位置，您可以明确配置它，以便访问您本地构建的 Maven 工件。在 org.ops4j.pax.url.mvn.cfg 配置文件中，取消注释 org.ops4j.pax.url.mvn.localRepository 属性，并将其设置为本地 Maven 存储库的位置。例如：

# Path to the local maven repository which is used to avoid downloading
# artifacts when they already exist locally.
# The value of this property will be extracted from the settings.xml file
# above, or defaulted to:
#     System.getProperty( "user.home" ) + "/.m2/repository"
#
org.ops4j.pax.url.mvn.localRepository=file:E:/Data/.m2/repository

有关 mvn URL 语法的详情，请查看原始 Pax URL Mvn 协议 文档。

如果您需要引用尚未打包为捆绑包的 JAR 文件，您可以使用 Wrap URL 处理程序来动态转换它。Wrap URL 处理程序的实施基于 Peter Krien 的开源 Bnd 实用程序。

Wrap URL 的语法如下：

wrap:locationURL[,instructionsURL][$instructions]

locationURL 可以是找到 JAR 的任何 URL （引用 JAR 的位置 不是 捆绑包的格式化）。可选 的说明URL 引用一个第二属性文件，该文件指定如何执行捆绑包转换。可选 的说明 是一个 符号，以及 分隔的 Bnd 属性列表，用于指定如何执行捆绑包转换。

在大多数情况下，默认的 Bnd 指令适合嵌套 API JAR 文件。默认情况下，Wrap 将清单标头添加到 JAR 的 META-INF/Manifest.mf 文件中，如 表 14.1 “用于编写 JAR 的默认指令” 所示。

以下 Wrap URL 在 Maven 存储库中找到 commons-logging JAR 版本 1.1，并使用默认的 Bnd 属性将其转换为 OSGi 捆绑包：

wrap:mvn:commons-logging/commons-logging/1.1

以下 Wrap URL 使用来自文件 E:\Data\Examples\commons-logging-1.1.bnd 的 Bnd 属性：

wrap:mvn:commons-logging/commons-logging/1.1,file:E:/Data/Examples/commons-logging-1.1.bnd

以下 Wrap URL 明确指定 Bundle-SymbolicName 属性和 Bundle-Version 属性：

wrap:mvn:commons-logging/commons-logging/1.1$Bundle-SymbolicName=apache-comm-log&Bundle-Version=1.1

如果前面的 URL 用作命令行参数，则可能需要转义 $ 符号 \$ 以防止命令行处理它，如下所示：

wrap:mvn:commons-logging/commons-logging/1.1\$Bundle-SymbolicName=apache-comm-log&Bundle-Version=1.1

有关 嵌套 URL 处理程序的详情，请查看以下引用：

如果您需要在 OSGi 容器中部署 WAR 文件，您可以通过为 war 前缀的 WAR URL 自动将必要的清单标头添加到 WAR 文件中，如下所述。

使用以下语法之一指定 War URL：

war:warURL
warref:instructionsURL

第一个语法（使用 war 方案）指定一个 WAR 文件，该文件使用默认指令转换为捆绑包中。warURL 可以是找到 WAR 文件的任何 URL。

第二个语法使用 warref 方案，指定第二属性文件 instructionsURL，其中包含转换指令（包括特定于此处理程序的一些指令）。在这个语法中，引用 WAR 文件的位置 不会在 URL 中明确显示。WAR 文件由属性文件中的（必需） WAR-URL 属性指定。

.bnd 指令文件中的一些属性特定于 War URL 处理程序，如下所示：

默认情况下，War URL 处理程序将清单标头添加到 WAR 的 META-INF/Manifest.mf 文件中，如 表 14.2 “用于编写 WAR 文件的默认说明” 所示。

以下 War URL 在 Maven 存储库中找到 wicket-examples WAR 的 1.4.7 版本，并使用默认说明将其转换为 OSGi 捆绑包：

war:mvn:org.apache.wicket/wicket-examples/1.4.7/war

以下 Wrap URL 明确指定 Web-ContextPath ：

war:mvn:org.apache.wicket/wicket-examples/1.4.7/war?Web-ContextPath=wicket

以下 War URL 会将 WAR-URL 属性引用的 WAR 文件转换为 wicket-examples-1.4.7.bnd 文件中的 WAR 文件，然后使用 .bnd 文件中的其他指令将 WAR 转换为 OSGi 捆绑包：

warref:file:E:/Data/Examples/wicket-examples-1.4.7.bnd

有关 war URL 语法的详情，请查看原始 Pax URL 封装 协议 文档。

要在控制台中查看可用命令列表，您可以使用 帮助 ：

karaf@root()> help
bundle                            Enter the subshell
bundle:capabilities               Displays OSGi capabilities of a given bundles.
bundle:classes                    Displays a list of classes/resources contained in the bundle
bundle:diag                       Displays diagnostic information why a bundle is not Active
bundle:dynamic-import             Enables/disables dynamic-import for a given bundle.
bundle:find-class                 Locates a specified class in any deployed bundle
bundle:headers                    Displays OSGi headers of a given bundles.
bundle:id                         Gets the bundle ID.
...

您有带有简短描述的所有命令列表。

您可以使用 tab 键获取所有命令的快速列表：

karaf@root()> Display all 294 possibilities? (y or n)
...

命令具有范围和名称。例如，命令 feature:list 具有 scope，并列出 为 name。

2008 年按范围"组"命令。每个范围组成一个子 shell。

您可以使用全限定名称(scope:name)直接执行命令：

karaf@root()> feature:list
...

或者，在子 shell 中输入命令上下文到子 shell：

karaf@root()> feature
karaf@root(feature)> list

请注意，您可以通过输入子 shell 名称（此处为 功能）直接输入子 shell。您可以直接从子 shell "switch" 改为另一个：

karaf@root()> feature
karaf@root(feature)> bundle
karaf@root(bundle)>

提示符显示（）之间的当前子 shell。

exit 命令进入父子 shell：

karaf@root()> feature
karaf@root(feature)> exit
karaf@root()>

完成模式定义了 tab 键和 help 命令的行为。

您有三种不同的模式可用：

您可以使用 etc/org.apache.karaf.shell.cfg 文件中的 completionMode 属性来定义默认的完成模式。默认情况下，您有：

completionMode = GLOBAL

您还可以使用 shell:completion 命令更改完成模式"实时" （使用 Karaf shell 控制台）：

karaf@root()> shell:completion
GLOBAL
karaf@root()> shell:completion FIRST
karaf@root()> shell:completion
FIRST

shell: 补全 可以告知您当前使用的完成模式。您还可以提供您想要的新完成模式。

GLOBAL 完成模式是 Karaf 4.0.0 中的默认模式（主要用于转换目的）。

GLOBAL 模式并不实际使用 subshell：它与之前 Karaf 版本的行为相同。

当您输入 tab 键时，无论您在哪个子 shell 中，都会显示所有命令和所有别名：

karaf@root()> <TAB>
karaf@root()> Display all 273 possibilities? (y or n)
...
karaf@root()> feature
karaf@root(feature)> <TAB>
karaf@root(feature)> Display all 273 possibilities? (y or n)

FIRST 完成模式是 GLOBAL 完成模式的替代选择。

如果您在 root 级别 subshell 上输入 tab 键，则完成将显示所有子 shell 中的命令和别名（如 GLOBAL 模式）。但是，如果您在子 shell 中键入了 tab 键，则完成将仅显示当前子 shell 的命令：

karaf@root()> shell:completion FIRST
karaf@root()> <TAB>
karaf@root()> Display all 273 possibilities? (y or n)
...
karaf@root()> feature
karaf@root(feature)> <TAB>
karaf@root(feature)>
info install list repo-add repo-list repo-remove uninstall version-list
karaf@root(feature)> exit
karaf@root()> log
karaf@root(log)> <TAB>
karaf@root(log)>
clear display exception-display get log set tail

SUBSHELL completion 模式是实际的子 shell 模式。

如果您在根级别上输入 tab 键，则完成会显示子 shell 命令（转至子 shell）和全局别名。在子 shell 中后，如果您键入 TAB 密钥，则完成会显示当前子 shell 的命令：

karaf@root()> shell:completion SUBSHELL
karaf@root()> <TAB>
karaf@root()>
* bundle cl config dev feature help instance jaas kar la ld lde log log:list man package region service shell ssh system
karaf@root()> bundle
karaf@root(bundle)> <TAB>
karaf@root(bundle)>
capabilities classes diag dynamic-import find-class headers info install list refresh requirements resolve restart services start start-level stop
uninstall update watch
karaf@root(bundle)> exit
karaf@root()> camel
karaf@root(camel)> <TAB>
karaf@root(camel)>
backlog-tracer-dump backlog-tracer-info backlog-tracer-start backlog-tracer-stop context-info context-list context-start context-stop endpoint-list route-info route-list route-profile route-reset-stats
route-resume route-show route-start route-stop route-suspend

Karaf 控制台提供完整的 Unix 环境，如环境。

karaf@root()> help feature:list
karaf@root()> man feature:list
karaf@root()> feature:list --help

DESCRIPTION
        feature:list

        Lists all existing features available from the defined repositories.

SYNTAX
        feature:list [options]

OPTIONS
        --help
                Display this help message
        -o, --ordered
                Display a list using alphabetical order
        -i, --installed
                Display a list of all installed features only
        --no-format
                Disable table rendered output

karaf@root()> alias "list-features-installed = { feature:list -i }"
karaf@root()> list-features-installed
Name       | Version | Required | State   | Repository     | Description
------------------------------------------------------------------------------------------------------------------------------
feature    | 4.0.0   | x        | Started | standard-4.0.0 | Features Support
shell      | 4.0.0   | x        | Started | standard-4.0.0 | Karaf Shell
deployer   | 4.0.0   | x        | Started | standard-4.0.0 | Karaf Deployer
bundle     | 4.0.0   | x        | Started | standard-4.0.0 | Provide Bundle support
config     | 4.0.0   | x        | Started | standard-4.0.0 | Provide OSGi ConfigAdmin support
diagnostic | 4.0.0   | x        | Started | standard-4.0.0 | Provide Diagnostic support
instance   | 4.0.0   | x        | Started | standard-4.0.0 | Provide Instance support
jaas       | 4.0.0   | x        | Started | standard-4.0.0 | Provide JAAS support
log        | 4.0.0   | x        | Started | standard-4.0.0 | Provide Log support
package    | 4.0.0   | x        | Started | standard-4.0.0 | Package commands and mbeans
service    | 4.0.0   | x        | Started | standard-4.0.0 | Provide Service support
system     | 4.0.0   | x        | Started | standard-4.0.0 | Provide System support
kar        | 4.0.0   | x        | Started | standard-4.0.0 | Provide KAR (KARaf archive) support
ssh        | 4.0.0   | x        | Started | standard-4.0.0 | Provide a SSHd server on Karaf
management | 4.0.0   | x        | Started | standard-4.0.0 | Provide a JMX MBeanServer and a set of MBeans in

ld = { log:display $args } ;
lde = { log:exception-display $args } ;
la = { bundle:list -t 0 $args } ;
ls = { service:list $args } ;
cl = { config:list "(service.pid=$args)" } ;
halt = { system:shutdown -h -f $args } ;
help = { *:help $args | more } ;
man = { help $args } ;
log:list = { log:get ALL } ;

karaf@root()> feature:list |grep -i war
pax-war                       | 4.1.4                            |          | Uninstalled | org.ops4j.pax.web-4.1.4  | Provide support of a full WebContainer
pax-war-tomcat                | 4.1.4                            |          | Uninstalled | org.ops4j.pax.web-4.1.4  |
war                           | 4.0.0                            |          | Uninstalled | standard-4.0.0           | Turn Karaf as a full WebContainer
blueprint-web                 | 4.0.0                            |          | Uninstalled | standard-4.0.0           | Provides an OSGI-aware Servlet ContextListener fo

karaf@root()> list = [1 2 3]; each ($list) { echo $it }
1
2
3

karaf@root()> a = 0 ; while { %((a+=1) <= 3) } { echo $a }
1
2
3

karaf@root()> list = ["Hello" world]; echo ($list get 0) ($list get 1)
Hello world

karaf@root()> $list class
...
ProtectionDomain     ProtectionDomain  null
 null
 <no principals>
 java.security.Permissions@6521c24e (
 ("java.security.AllPermission" "<all permissions>" "<all actions>")
)


Signers              null
SimpleName           ArrayList
TypeParameters       [E]

karaf@root()> ("hello world" toCharArray)
[h, e, l, l, o,  , w, o, r, l, d]

karaf@root()> ("hello world" toCharArray)[0]
Error executing command: [C cannot be cast to [Ljava.lang.Object;

karaf@root> shell:source script.txt
True!

foo = "foo"
if { $foo equals "foo" } {
  echo "True!"
}

if{ $foo equals "foo" } ...

karaf@root> shell:source script.txt
Error executing command: Cannot coerce echo "true!"() to any of []

Apache Karaf 控制台支持基于角色的访问控制(RBAC)安全机制。这意味着，根据连接到控制台的用户，您可以定义取决于用户的组和角色、执行某些命令的权限或限制参数允许的值。

此用户指南的 Security 部分中详述了 控制台安全性。

通过配置应用程序，它意味着安装所有模块、配置和传输的应用程序。

它原生支持部署 OSGi 应用程序。

OSGi 应用程序是一组 OSGi 捆绑包。OSGi 捆绑包是一个常规 jar 文件，它带有 jar MANIFEST 中的附加元数据。

在 OSGi 中，捆绑包可以依赖于其他捆绑包。因此，这意味着，在大多数时候部署 OSGi 应用程序，您首先需要部署应用程序所需的大量其他捆绑包。

因此，您必须首先找到这些捆绑包，安装捆绑包。同样，这些"独立"捆绑包可能需要其他捆绑包来满足自己的依赖项。

更深入，应用程序还需要配置（请参阅用户指南的 [Configuration section|configuration]）。因此，在启动应用程序之前，除了依赖项捆绑包外，您必须创建或部署配置。

正如我们所见，应用程序的调配可能非常长且快速。

Apache Karaf 为调配应用提供了简单而灵活的方式。

在 Apache Karaf 中，应用调配是 Apache Karaf "功能"。

功能将应用程序描述为：

安装功能时，Apache Karaf 将安装功能中描述的所有资源。这意味着，它将自动解析和安装功能中描述的所有捆绑包、配置和依赖项功能。

功能解析器检查服务要求，并安装提供符合要求的服务的捆绑包。默认模式只对"新风格"功能启用此行为（基本来说，带有等于或大于 1.3.0 的架构仓库 XML）。它不适用于"旧的"功能存储库（从 Karaf 2 或 3 开始）。

您可以使用 serviceRequirements 属性更改 etc/org.apache.karaf.features.cfg 文件中的服务要求强制模式。

serviceRequirements=default

可能的值有：

此外，功能也可以定义要求。在这种情况下，2019 年可以自动额外的捆绑包或功能，提供满足要求的功能。

功能具有完整的生命周期：install、start、stop、update、uninstall。

该功能在 XML 描述符中描述。此 XML 文件包含一组功能的描述。

功能 XML 描述符被命名为 "features repository"。在能够安装功能前，您必须注册提供该功能的功能存储库（使用 feature:repo-add 命令或 FeatureMBean ），如稍后所述。

例如，以下 XML 文件（或"features 存储库"）描述了 feature1 和 feature2 功能：

<features xmlns="http://karaf.apache.org/xmlns/features/v1.3.0">
  <feature name="feature1" version="1.0.0">
    <bundle>...</bundle>
    <bundle>...</bundle>
  </feature>
  <feature name="feature2" version="1.1.0">
    <feature>feature1</feature>
    <bundle>...</bundle>
  </feature>
</features>

我们可以注意到，功能 XML 具有模式。详情请参阅 用户指南的 [Features XML Schema 部分|provisioning-schema]。feature1 功能在 1.0.0 版本中可用，包含两个捆绑包。& lt;bundle/& gt; 元素包含捆绑包工件的 URL （请参阅 [Artifacts repositories 和 URL 部分|urls] 部分）。如果您安装 feature1 功能（使用 feature:install 或 FeatureMBean），则 Apache Karaf 将自动安装上述两个捆绑包。feature2 功能在 1.1.0 版本中提供，包含对 feature1 功能和捆绑包的引用。& lt;feature/& gt; 元素包含功能的名称。可以使用 version 属性到 <feature/&gt ; 元素(& lt;feature version="1.0.0">feature1</feature>)来定义特定的功能版本。如果没有指定 version 属性，则 Apache Karaf 将安装最新的可用版本。如果您安装 feature2 功能（使用 feature:install 或 FeatureMBean），则 Apache Karaf 将自动安装 feature1 （如果尚未安装）和捆绑包。

功能存储库使用到功能 XML 文件的 URL 注册。

features 状态存储在 Apache Karaf 缓存中（在 KARAF_DATA 文件夹中）。您可以重新启动 Apache Karaf，之前安装的功能仍然保持安装并在重新启动后可用。如果您进行干净的重启，或者删除 Apache Karaf 缓存（删除 KARAF_DATA 文件夹），则之前注册的软件仓库和功能都将丢失：您必须注册功能并再次安装功能。要防止这种情况，您可以将功能指定为引导功能。

您可以将一些功能描述为引导功能。Apache Karaf 将自动安装引导功能，即使之前还没有使用 feature:install 或 FeatureMBean 安装。

Apache Karaf 功能配置位于 etc/org.apache.karaf.features.cfg 配置文件中。

此配置文件包含用于定义引导功能的两个属性：

您可以通过安装相同的功能（具有相同的 SNAPSHOT 版本或不同的版本）来更新发行版本。

由于功能生命周期，您可以控制功能的状态（启动、停止等）。

您还可以使用模拟来查看更新的作用。

功能中定义的捆绑包可以使用文件 etc/overrides.properties 覆盖。文件中的每一行都定义一个覆盖。语法为：<bundle-uri>[;range="[min,max）"]，如果覆盖的版本大于覆盖捆绑包的版本，则给定的捆绑包将使用相同的符号名称覆盖所有捆绑包定义中。如果未指定范围，则假定为微版本级别的兼容性。

例如，覆盖 mvn:org.ops4j.pax.logging/pax-logging-service/1.8.5 会过度使用 pax-logging-service 1.8.3，而不是 1.8.6 或 1.7.0。

功能可以依赖于一组其他功能：

  <feature name="my-project" version="1.0.0">
    <feature>other</feature>
    <bundle start-level="80" start="false">mvn:com.mycompany.myproject/myproject-dao</bundle>
    <bundle start-level="85" start="false">mvn:com.mycompany.myproject/myproject-service</bundle>
  </feature>

将安装 my-project 功能时，也会自动安装 其他功能。

可以为依赖功能定义版本范围：

<feature name="spring-dm">
  <feature version="[2.5.6,4)">spring</feature>
  ...
</feature>

将安装范围内最高版本的功能。

如果指定了单个版本，则范围将被视为开放。

如果未指定，将安装可用最高的可用。

要指定准确的版本，请使用关闭的范围，如 [3.1,3.1]。

功能 XML 中的 <config /> 元素允许功能创建和/或填充配置（由配置 PID 识别）。

<config name="com.foo.bar">
  myProperty = myValue
</config>

< config/> 元素的 name 属性对应于配置 PID （详情请参阅 [Configuration section|configuration] ）。

功能的安装效果与在 etc 文件夹中丢弃名为 com.foo.bar.cfg 的文件具有相同的效果。

< config/&gt; 元素的内容是一组属性，遵循 key=value 标准。

功能可以指定 &lt ;config file/& gt; 元素，而不使用 <config/> 元素。

<configfile finalname="/etc/myfile.cfg" override="false">URL</configfile>

< config/> 元素不直接操作 Apache Karaf 配置层（如使用 &lt; config/&gt; 元素时），<configfile/> 元素直接取一个由 URL 指定的文件，并将该文件复制到 finalname 属性指定的位置。

如果没有指定，则位置来自 KARAF_BASE 变量。也可以使用诸如 ${karaf.home}、${karaf.base}、${karaf.etc} 或系统属性等变量。

例如：

<configfile finalname="${karaf.etc}/myfile.cfg" override="false">URL</configfile>

如果该文件已存在于所需的位置，并且跳过了配置文件部署，因为已存在的文件可能包含自定义。此行为可以通过覆盖设置为 true 来覆盖。

文件 URL 是 Apache Karaf 支持的 URL （有关详细信息，请参阅用户指南的 [Artifacts 存储库和 URL|urls]）。

<requirement>osgi.ee;filter:=&quot;(&amp;(osgi.ee=JavaSE)(!(version&gt;=1.8)))&quot;</requirement>

您可以通过在 deploy 文件夹中直接丢弃该文件来"热部署"功能 XML。

Apache Karaf 提供功能部署器。

当您丢弃 deploy 文件夹中的功能 XML 时，功能部署器将执行：* 将功能 XML 注册为功能存储库，并将 install 属性设置为 "auto" 的功能由部署器自动安装。

例如，丢弃部署文件夹中的以下 XML 将自动安装 feature1 和 feature2，而 feature3 不会被安装：

<?xml version="1.0" encoding="UTF-8"?>
<features name="my-features" xmlns="http://karaf.apache.org/xmlns/features/v1.3.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.3.0 http://karaf.apache.org/xmlns/features/v1.3.0">

    <feature name="feature1" version="1.0" install="auto">
        ...
    </feature>

    <feature name="feature2" version="1.0" install="auto">
        ...
    </feature>

    <feature name="feature3" version="1.0">
        ...
    </feature>

</features>

在 JMX 层上，您有一个 MBean 专用于管理功能和特性存储库： FeatureMBean。

FeatureMBean 对象名称是： org.apache.karaf:type=feature,name iwl.

当您以默认模式或 第 2.1.3 节 “在服务器模式中启动运行时” 中启动 Red Hat Fuse 运行时，它允许通过 SSH 从任何其他 Fuse 控制台访问的远程控制台。远程控制台提供本地控制台的所有功能，并允许远程用户对容器及其内部运行的服务进行完全控制。

SSH 主机名和端口号在 INSTALL_DIR/etc/org.apache.karaf.shell.cfg 配置文件中配置。更改远程访问的端口 显示更改用于 8102 端口的示例配置。

sshPort=8102
sshHost=0.0.0.0

Maven 构建系统最重要的原则之一是 Maven 项目中所有文件的标准位置。这个原则有几个优点。一个优点是 Maven 项目通常具有相同的目录布局，因此可以轻松地在项目中找到文件。另一个优点是，与 Maven 集成的各种工具需要 几乎不需要 初始配置。例如，Java 编译器知道它应当编译 src/main/java 下的所有源文件，并将结果置于 target/classes 中。

例 17.1 “标准 Maven 目录布局” 显示与构建 OSGi 捆绑包项目相关的标准 Maven 目录布局的元素。此外，还显示了蓝图配置文件( 不是由 Maven 定义)的标准位置。

ProjectDir/
    pom.xml
    src/
        main/
            java/
                ...
            resources/
                META-INF/

                OSGI-INF/
                    blueprint/
                        *.xml
        test/
            java/
            resources/
    target/
        ...

pom.xml 文件是当前项目的项目对象模型(POM)，其中包含如何构建当前项目的完整描述。pom.xml 文件可以完全自包含，但通常（对于更复杂的 Maven 项目而言），它可以 从父 POM 文件导入设置。

构建项目后，在生成的 JAR 文件中的以下位置自动嵌入 pom.xml 文件的副本：

META-INF/maven/groupId/artifactId/pom.xml

src/ 目录包含您在开发项目时工作的所有代码和资源文件。

target/ 目录包含构建的结果（通常是 JAR 文件），以及构建期间生成的所有中间文件。例如，在执行构建后，target/classes/ 目录将包含资源文件的副本以及已编译的 Java 类。

src/main/ 目录包含构建工件所需的所有代码和资源。

src/test/ 目录包含针对编译的工件运行单元测试的所有代码和资源。

每个 java/ 子目录都包含带有标准 Java 目录布局（即目录路径名称的 Java 源代码）的 Java 源代码(.java 文件)，其中目录名会镜像 Java 软件包名，其 / 代替 . 字符。src/main/java/ 目录包含捆绑包源代码，而 src/test/java/ 目录包含单元测试源代码。

如果您有捆绑包中包含的任何配置文件、数据文件或 Java 属性，则这些配置文件应放在 src/main/resources/ 目录下。src/main/resources/ 下的文件和目录将复制到 Maven 构建过程生成的 JAR 文件的根目录中。

src/test/resources/ 下的文件仅在测试阶段使用，且不会 复制到生成的 JAR 文件中。

OSGi R4.2 定义蓝图容器。Red Hat Fuse 对 Blueprint 容器内置了支持，只需在项目中包含 Blueprint 配置文件 OSGI-INF/blueprintAttr.xml 即可启用这些容器。有关 Blueprint 容器的详情，请参考 第 12 章 OSGi 服务。

初始日志配置从 etc/org.ops4j.pax.logging.cfg 加载。

此文件是 标准 Log4j2 配置文件。

找到不同的 Log4j2 元素：

您可以在 文件中直接添加自己的初始配置。

默认配置如下：

#
#  Copyright 2005-2018 Red Hat, Inc.
#
#  Red Hat licenses this file to you under the Apache License, version
#  2.0 (the "License"); you may not use this file except in compliance
#  with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#  implied.  See the License for the specific language governing
#  permissions and limitations under the License.
#

#
# Internal Log4j2 configuration
#
log4j2.status = WARN
log4j2.verbose = false
log4j2.dest = out

#
# Common pattern layouts for appenders defined as reusable properties
# See https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout
# references will be replaced by felix.fileinstall
#
log4j2.pattern = %d{DEFAULT} | %-5.5p | %-20.20t | %-32.32c{1.} | %X{bundle.id} - %X{bundle.name} - %X{bundle.version} | %m%n
#log4j2.pattern = %d{DEFAULT} %-5.5p {%t} [%C.%M()] (%F:%L) : %m%n

#
# Appenders configuration
#

# JDBC Appender
log4j2.appender.jdbc.type = JDBC
log4j2.appender.jdbc.name = JdbcAppender
log4j2.appender.jdbc.tableName = EVENTS
log4j2.appender.jdbc.cs.type = DataSource
log4j2.appender.jdbc.cs.lazy = true
log4j2.appender.jdbc.cs.jndiName = osgi:service/jdbc/logdb
log4j2.appender.jdbc.c1.type = Column
log4j2.appender.jdbc.c1.name = DATE
log4j2.appender.jdbc.c1.isEventTimestamp = true
log4j2.appender.jdbc.c2.type = Column
log4j2.appender.jdbc.c2.name = LEVEL
log4j2.appender.jdbc.c2.pattern = %level
log4j2.appender.jdbc.c2.isUnicode = false
log4j2.appender.jdbc.c3.type = Column
log4j2.appender.jdbc.c3.name = SOURCE
log4j2.appender.jdbc.c3.pattern = %logger
log4j2.appender.jdbc.c3.isUnicode = false
log4j2.appender.jdbc.c4.type = Column
log4j2.appender.jdbc.c4.name = THREAD_ID
log4j2.appender.jdbc.c4.pattern = %thread
log4j2.appender.jdbc.c4.isUnicode = false
log4j2.appender.jdbc.c5.type = Column
log4j2.appender.jdbc.c5.name = MESSAGE
log4j2.appender.jdbc.c5.pattern = %message
log4j2.appender.jdbc.c5.isUnicode = false


# Console appender not used by default (see log4j2.rootLogger.appenderRefs)
log4j2.appender.console.type = Console
log4j2.appender.console.name = Console
log4j2.appender.console.layout.type = PatternLayout
log4j2.appender.console.layout.pattern = ${log4j2.pattern}

# Rolling file appender
log4j2.appender.rolling.type = RollingRandomAccessFile
log4j2.appender.rolling.name = RollingFile
log4j2.appender.rolling.fileName = ${karaf.data}/log/fuse.log
log4j2.appender.rolling.filePattern = ${karaf.data}/log/fuse-%i.log.gz
# uncomment to not force a disk flush
#log4j2.appender.rolling.immediateFlush = false
log4j2.appender.rolling.append = true
log4j2.appender.rolling.layout.type = PatternLayout
log4j2.appender.rolling.layout.pattern = ${log4j2.pattern}
log4j2.appender.rolling.policies.type = Policies
log4j2.appender.rolling.policies.size.type = SizeBasedTriggeringPolicy
log4j2.appender.rolling.policies.size.size = 16MB
log4j2.appender.rolling.strategy.type = DefaultRolloverStrategy
log4j2.appender.rolling.strategy.max = 20

# Audit file appender
log4j2.appender.audit.type = RollingRandomAccessFile
log4j2.appender.audit.name = AuditRollingFile
log4j2.appender.audit.fileName = ${karaf.data}/security/audit.log
log4j2.appender.audit.filePattern = ${karaf.data}/security/audit.log.%i
log4j2.appender.audit.append = true
log4j2.appender.audit.layout.type = PatternLayout
log4j2.appender.audit.layout.pattern = ${log4j2.pattern}
log4j2.appender.audit.policies.type = Policies
log4j2.appender.audit.policies.size.type = SizeBasedTriggeringPolicy
log4j2.appender.audit.policies.size.size = 8MB

# OSGi appender
log4j2.appender.osgi.type = PaxOsgi
log4j2.appender.osgi.name = PaxOsgi
log4j2.appender.osgi.filter = *

#
# Loggers configuration
#

# Root logger
log4j2.rootLogger.level = INFO
log4j2.rootLogger.appenderRef.RollingFile.ref = RollingFile
log4j2.rootLogger.appenderRef.PaxOsgi.ref = PaxOsgi
log4j2.rootLogger.appenderRef.Console.ref = Console
log4j2.rootLogger.appenderRef.Console.filter.threshold.type = ThresholdFilter
log4j2.rootLogger.appenderRef.Console.filter.threshold.level = ${karaf.log.console:-OFF}
#log4j2.rootLogger.appenderRef.Sift.ref = Routing

# Spifly logger
log4j2.logger.spifly.name = org.apache.aries.spifly
log4j2.logger.spifly.level = WARN

# Security audit logger
log4j2.logger.audit.name = org.apache.karaf.jaas.modules.audit
log4j2.logger.audit.level = INFO
log4j2.logger.audit.additivity = false
log4j2.logger.audit.appenderRef.AuditRollingFile.ref = AuditRollingFile

# help with identification of maven-related problems with pax-url-aether
#log4j2.logger.aether.name = shaded.org.eclipse.aether
#log4j2.logger.aether.level = TRACE
#log4j2.logger.http-headers.name = shaded.org.apache.http.headers
#log4j2.logger.http-headers.level = DEBUG
#log4j2.logger.maven.name = org.ops4j.pax.url.mvn
#log4j2.logger.maven.level = TRACE

默认配置使用 out 文件 appender 定义 ROOT 日志记录器，其 INFO 日志级别。您可以将日志级别更改为任何 Log4j2 有效值。从最详细到最详细的信息，您可以指定 TRACE, DEBUG, INFO, ERROR, 或 FATAL。

要启用它，您必须在 rootLogger 中添加 stdout 附加程序：

log4j2.rootLogger=INFO, out, stdout, osgi:*

log4j2.appender.jdbc.cs.lazy = true

Apache Karaf 不是更改 etc/org.ops4j.pax.logging.cfg 文件，而是提供一组命令来动态更改日志配置并查看日志内容：

karaf@root()> log:display
2015-07-01 19:12:46,208 | INFO  | FelixStartLevel  | SecurityUtils                    | 16 - org.apache.sshd.core - 0.12.0 | BouncyCastle not registered, using the default JCE provider
2015-07-01 19:12:47,368 | INFO  | FelixStartLevel  | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Starting JMX OSGi agent

karaf@root()> log:display ssh
2015-07-01 19:12:46,208 | INFO  | FelixStartLevel  | SecurityUtils                    | 16 - org.apache.sshd.core - 0.12.0 | BouncyCastle not registered, using the default JCE provider

karaf@root()> log:display -n 5
2015-07-01 06:53:24,143 | INFO  | JMX OSGi Agent   | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering org.osgi.jmx.framework.BundleStateMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.core:type=bundleState,version=1.7,framework=org.apache.felix.framework,uuid=5335370f-9dee-449f-9b1c-cabe74432ed1
2015-07-01 06:53:24,150 | INFO  | JMX OSGi Agent   | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering org.osgi.jmx.framework.PackageStateMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.core:type=packageState,version=1.5,framework=org.apache.felix.framework,uuid=5335370f-9dee-449f-9b1c-cabe74432ed1
2015-07-01 06:53:24,150 | INFO  | JMX OSGi Agent   | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering org.osgi.jmx.framework.ServiceStateMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.core:type=serviceState,version=1.7,framework=org.apache.felix.framework,uuid=5335370f-9dee-449f-9b1c-cabe74432ed1
2015-07-01 06:53:24,152 | INFO  | JMX OSGi Agent   | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering org.osgi.jmx.framework.wiring.BundleWiringStateMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.core:type=wiringState,version=1.1,framework=org.apache.felix.framework,uuid=5335370f-9dee-449f-9b1c-cabe74432ed1
2015-07-01 06:53:24,501 | INFO  | FelixStartLevel  | RegionsPersistenceImpl           | 78 - org.apache.karaf.region.persist - 4.0.0 | Loading region digraph persistence

#
# The number of log statements to be displayed using log:display. It also defines the number
# of lines searched for exceptions using log:display exception. You can override this value
# at runtime using -n in log:display.
#
size = 500

#
# The pattern used to format the log statement when using log:display. This pattern is according
# to the log4j2 layout. You can override this parameter at runtime using log:display with -p.
#
pattern = %d{ISO8601} | %-5.5p | %-16.16t | %-32.32c{1} | %X{bundle.id} - %X{bundle.name} - %X{bundle.version} | %m%n

karaf@root()> log:display -p "\%d - \%c - \%m\%n"
2015-07-01 07:01:58,007 - org.apache.sshd.common.util.SecurityUtils - BouncyCastle not registered, using the default JCE provider
2015-07-01 07:01:58,725 - org.apache.aries.jmx.core - Starting JMX OSGi agent
2015-07-01 07:01:58,744 - org.apache.aries.jmx.core - Registering MBean with ObjectName [osgi.compendium:service=cm,version=1.3,framework=org.apache.felix.framework,uuid=6361fc65-8df4-4886-b0a6-479df2d61c83] for service with service.id [13]
2015-07-01 07:01:58,747 - org.apache.aries.jmx.core - Registering org.osgi.jmx.service.cm.ConfigurationAdminMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.compendium:service=cm,version=1.3,framework=org.apache.felix.framework,uuid=6361fc65-8df4-4886-b0a6-479df2d61c83

karaf@root()> log:get
Logger                              │ Level
────────────────────────────────────┼──────
ROOT                                │ INFO
org.apache.aries.spifly             │ WARN
org.apache.karaf.jaas.modules.audit │ INFO
org.apache.sshd                     │ INFO

karaf@root()> log:get ssh
INFO

log4j2.logger.my.name = MyLogger
log4j2.logger.my.level = DEBUG

karaf@root()> log:get ALL
Logger                              │ Level
────────────────────────────────────┼──────
MyLogger                            │ DEBUG
ROOT                                │ INFO
org.apache.aries.spifly             │ WARN
org.apache.karaf.jaas.modules.audit │ INFO
org.apache.sshd                     │ INFO

karaf@root()> log:log "Hello World"
karaf@root()> log:display
12:55:21.706 INFO [pipe-log:log "Hello World"] Hello World

karaf@root()> log:clear
karaf@root()> log:log -l ERROR "Hello World"
karaf@root()> log:display
12:55:41.460 ERROR [pipe-log:log "Hello World"] Hello World

karaf@root()> log:set DEBUG
karaf@root()> log:get
Logger                              │ Level
────────────────────────────────────┼──────
ROOT                                │ DEBUG
...

karaf@root()> log:set INFO my.logger
karaf@root()> log:get my.logger
Logger    | Level
-----------------
my.logger | INFO

rootLogger=INFO,out,osgi:*
my.logger=INFO,appender1
my.logger.custom=DEBUG,appender2

karaf@root()> log:set INFO my.logger.custom

rootLogger=INFO,out,osgi:*
my.logger=INFO,appender1
my.logger.custom=INFO,appender2

karaf@root()> log:set DEFAULT my.logger.custom

rootLogger=INFO,out,osgi:*
my.logger=INFO,appender1
my.logger.custom=appender2

karaf@root()> log:set DEFAULT my.logger

rootLogger=INFO,out,osgi:*
my.logger=appender1
my.logger.custom=appender2

karaf@root()> log:tail
2015-07-01 07:40:28,152 | INFO  | FelixStartLevel  | SecurityUtils                    | 16 - org.apache.sshd.core - 0.9.0 | BouncyCastle not registered, using the default JCE provider
2015-07-01 07:40:28,909 | INFO  | FelixStartLevel  | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Starting JMX OSGi agent
2015-07-01 07:40:28,928 | INFO  | FelixStartLevel  | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering MBean with ObjectName [osgi.compendium:service=cm,version=1.3,framework=org.apache.felix.framework,uuid=b44a44b7-41cd-498f-936d-3b12d7aafa7b] for service with service.id [13]
2015-07-01 07:40:28,936 | INFO  | JMX OSGi Agent   | core                             | 68 - org.apache.aries.jmx.core - 1.1.1 | Registering org.osgi.jmx.service.cm.ConfigurationAdminMBean to MBeanServer com.sun.jmx.mbeanserver.JmxMBeanServer@27cc75cb with name osgi.compendium:service=cm,version=1.3,framework=org.apache.felix.framework,uuid=b44a44b7-41cd-498f-936d-3b12d7aafa7b

您可以使用 Log MBean 命令执行的所有操作。

LogMBean 对象名称是 org.apache.karaf:type=log,name iwl。

正如我们所看到的那样，Apache Karaf 使用 PropertiesLoginModule。

此登录模块使用 etc/users.properties 文件作为用户、组、角色和密码的存储。

initial etc/users.properties 文件包含：

################################################################################
#
#    Licensed to the Apache Software Foundation (ASF) under one or more
#    contributor license agreements.  See the NOTICE file distributed with
#    this work for additional information regarding copyright ownership.
#    The ASF licenses this file to You under the Apache License, Version 2.0
#    (the "License"); you may not use this file except in compliance with
#    the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
################################################################################

#
# This file contains the users, groups, and roles.
# Each line has to be of the format:
#
# USER=PASSWORD,ROLE1,ROLE2,...
# USER=PASSWORD,_g_:GROUP,...
# _g_\:GROUP=ROLE1,ROLE2,...
#
# All users, grousp, and roles entered in this file are available after Karaf startup
# and modifiable via the JAAS command group. These users reside in a JAAS domain
# with the name "karaf".
#
karaf = karaf,_g_:admingroup
_g_\:admingroup = group,admin,manager,viewer

我们可以在此文件中看到，默认情况下我们有一个用户：karaf。默认密码是 karaf。

karaf 用户是一个组的成员： admingroup。

组始终以 g 前缀：没有此前缀的条目是一个用户。

组定义了一组角色。默认情况下，admin group 定义组、admin、manager 和 viewer 角色。

这意味着 karaf 用户将具有由 admingroup 定义的角色。

karaf@root()> jaas:realm-list
Index | Realm Name | Login Module Class Name
-----------------------------------------------------------------------------------
1     | karaf      | org.apache.karaf.jaas.modules.properties.PropertiesLoginModule
2     | karaf      | org.apache.karaf.jaas.modules.publickey.PublickeyLoginModule

karaf@root()> jaas:realm-manage --index 1

karaf@root()> jaas:realm-manage --realm karaf --module org.apache.karaf.jaas.modules.properties.PropertiesLoginModule

karaf@root()> jaas:user-list
User Name | Group      | Role
--------------------------------
karaf     | admingroup | admin
karaf     | admingroup | manager
karaf     | admingroup | viewer

karaf@root()> jaas:user-add foo bar

karaf@root()> jaas:update
karaf@root()> jaas:realm-manage --index 1
karaf@root()> jaas:user-list
User Name | Group      | Role
--------------------------------
karaf     | admingroup | admin
karaf     | admingroup | manager
karaf     | admingroup | viewer
foo       |            |

karaf@root()> jaas:user-delete foo

karaf@root()> jaas:update
karaf@root()> jaas:realm-manage --index 1
karaf@root()> jaas:user-list
User Name | Group      | Role
--------------------------------
karaf     | admingroup | admin
karaf     | admingroup | manager
karaf     | admingroup | viewer

karaf@root()> jaas:group-add karaf mygroup

karaf@root()> jaas:group-delete karaf mygroup

karaf@root()> jaas:group-role-add mygroup myrole

karaf@root()> jaas:group-role-delete mygroup myrole

默认情况下，密码以明文形式存储在 etc/users.properties 文件中。

可以在 etc/org.apache.karaf.jaas.cfg 配置文件中启用加密：

################################################################################
#
#    Licensed to the Apache Software Foundation (ASF) under one or more
#    contributor license agreements.  See the NOTICE file distributed with
#    this work for additional information regarding copyright ownership.
#    The ASF licenses this file to You under the Apache License, Version 2.0
#    (the "License"); you may not use this file except in compliance with
#    the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
################################################################################

#
# Boolean enabling / disabling encrypted passwords
#
encryption.enabled = false

#
# Encryption Service name
#   the default one is 'basic'
#   a more powerful one named 'jasypt' is available
#       when installing the encryption feature
#
encryption.name =

#
# Encryption prefix
#
encryption.prefix = {CRYPT}

#
# Encryption suffix
#
encryption.suffix = {CRYPT}

#
# Set the encryption algorithm to use in Karaf JAAS login module
# Supported encryption algorithms follow:
#   MD2
#   MD5
#   SHA-1
#   SHA-256
#   SHA-384
#   SHA-512
#
encryption.algorithm = MD5

#
# Encoding of the encrypted password.
# Can be:
#   hexadecimal
#   base64
#
encryption.encoding = hexadecimal

如果 encryption.enabled y 设为 true，则启用密码加密。

启用加密后，密码在第一次登录时加密。加密的密码的前缀为 \{CRYPT\}。要重新加密密码，您可以以明文形式重置密码（在 etc/users.properties 文件中），而无需 \{CRYPT\} 前缀和后缀。Apache Karaf 将检测到此密码的清除状态（因为它没有前缀为 \{CRYPT\}），并再次对其进行加密。

etc/org.apache.karaf.jaas.cfg 配置文件允许您定义高级加密行为：

对于 SSH 层，2019 年通过密钥支持身份验证，允许在不提供密码的情况下登录。

SSH 客户端(so bin/client 由 Karaf 本身提供，或者任何 ssh 客户端（如 OpenSSH)都使用一个公钥/私钥对，该密钥对将识别 Karaf SSHD （服务器端）上的自己。

允许连接的键存储在 etc/keys.properties 文件中，采用以下格式：

user=key,role

默认情况下，Tamener 允许 karaf 用户的密钥：

# karaf=AAAAB3NzaC1kc3MAAACBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAAAAFQCXYFCPFSMLzLKSuYKi64QL8Fgc9QAAAIEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoAAACBAKKSU2PFl/qOLxIwmBZPPIcJshVe7bVUpFvyl3BbJDow8rXfskl8wO63OzP/qLmcJM0+JbcRU/53JjTuyk31drV2qxhIOsLDC9dGCWj47Y7TyhPdXh/0dthTRBy6bqGtRPxGa7gJov1xm/UuYYXPIUR/3x9MAZvZ5xvE0kYXO+rx,admin

创建密钥对的最简单方法是使用 OpenSSH。

您可以使用以下方法创建密钥对：

ssh-keygen -t dsa -f karaf.id_dsa -N karaf

您现在有公钥和私钥：

-rw-------  1 jbonofre jbonofre    771 Jul 25 22:05 karaf.id_dsa
-rw-r--r--  1 jbonofre jbonofre    607 Jul 25 22:05 karaf.id_dsa.pub

您可以在 etc/keys.properties 中的 karaf.id_dsa.pub 文件的内容中复制：

karaf=AAAAB3NzaC1kc3MAAACBAJLj9vnEhu3/Q9Cvym2jRDaNWkATgQiHZxmErCmiLRuD5Klfv+HT/+8WoYdnvj0YaXFP80phYhzZ7fbIO2LRFhYhPmGLa9nSeOsQlFuX5A9kY1120yB2kxSIZI0fU2hy1UCgmTxdTQPSYtdWBJyvO/vczoX/8I3FziEfss07Hj1NAAAAFQD1dKEzkt4e7rBPDokPOMZigBh4kwAAAIEAiLnpbGNbKm8SNLUEc/fJFswg4G4VjjngjbPZAjhkYe4+H2uYmynry6V+GOTS2kaFQGZRf9XhSpSwfdxKtx7vCCaoH9bZ6S5Pe0voWmeBhJXi/Sww8f2stpitW2Oq7V7lDdDG81+N/D7/rKDD5PjUyMsVqc1n9wCTmfqmi6XPEw8AAACAHAGwPn/Mv7P9Q9+JZRWtGq+i4pL1zs1OluiStCN9e/Ok96t3gRVKPheQ6IwLacNjC9KkSKrLtsVyepGA+V5j/N+Cmsl6csZilnLvMUTvL/cmHDEEhTIQnPNrDDv+tED2BFqkajQqYLgMWeGVqXsBU6IT66itZlYtrq4v6uDQG/o=,admin

并指定客户端使用 karaf.id_dsa 私钥：

bin/client -k ~/karaf.id_dsa

或 ssh

ssh -p 8101 -i ~/karaf.id_dsa karaf@localhost

Apache Karaf 使用角色来控制对资源的访问：它是 RBAC （基于角色的访问控制）系统。

角色用于控制：

list = viewer
info = viewer
install = admin
uninstall = admin

#
# By default, only Karaf shell commands are secured, but additional services can be
# secured by expanding this filter
#
karaf.secured.services = (&(osgi.command.scope=*)(osgi.command.function=*))

karaf@root()> feature:install webconsole

Apache Karaf 提供了一个 JMX MBean，用于检查当前用户是否可以调用给定的 MBean 和/或操作。

canInvoke （） 操作获取当前用户的角色，并检查一个角色是否可以调用 MBean 和/或操作，最终具有给定参数值。

有些应用程序需要特定的安全供应商可用，如 [BouncyCastle|http://www.bouncycastle.org]。

JVM 对此类 jars 的使用施加一些限制：它们必须签名并在引导类路径上可用。

部署这些提供程序的一种方法是将其放在 $JAVA_HOME/jre/lib/ext 的 JRE 文件夹中，并修改安全策略配置($JAVA_HOME/jre/lib/security/java.security)以注册此类提供程序。

虽然这种方法可以正常工作，但它具有全局效果，但要求您相应地配置所有服务器。

Apache Karaf 提供了配置额外安全提供程序的简单方法：* 将您的供应商 jar 置于 lib/ext * 中，修改 etc/config.properties 配置文件以添加下列属性

org.apache.karaf.security.providers = xxx,yyy

此属性的值是要注册的供应商类名称的逗号分隔列表。

例如，要添加 bouncycastle 安全供应商，您可以定义：

org.apache.karaf.security.providers = org.bouncycastle.jce.provider.BouncyCastleProvider

此外，您可能还希望提供从系统捆绑包中对这些提供程序的类的访问权限，以便所有捆绑包都可以访问这些捆绑包。

它可以通过修改同一配置文件中的 org.osgi.framework.bootdelegation 属性来实现：

org.osgi.framework.bootdelegation = ...,org.bouncycastle*