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

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

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

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

OSGi 框架包含以下内容：

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

OSGi 服务是一个 Java 类或服务接口，其服务属性定义为名称/值对。服务属性区分有同一服务接口的服务提供程序。

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

服务接口允许捆绑包通过绑定接口而不是实现交互。服务接口应尽可能少地指定一些实施详情。

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

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

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

捆绑包负责运行时服务依赖关系管理活动，包括发布、发现和绑定。捆绑包还可适应与捆绑包绑定的服务动态可用性（arrival 或 departure）带来的变化。

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

Windows

set PATH=%PATH%;InstallDir\bin

Linux/UNIX

export PATH=$PATH,InstallDir/bin`

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

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，无需本地控制台。然后，您要使用远程控制台连接到正在运行的实例。详情请查看 第 17.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 客户端 启动 visual 实例，您可以在 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 文件中设置以下属性来自定义关闭端口：

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

Apache Karaf 运行时默认对网络攻击进行保护，因为所有公开的端口都需要用户身份验证，而且最初没有定义用户。换句话说，默认情况下可以远程访问 Apache Karaf 运行时。

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

如果要启用到 Karaf 容器的远程访问，您必须在启动容器前创建 secure JAAS 用户：

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

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

Username=Password,admin

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

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

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

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

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

容器公开以下端口：

您可以同时满足以下条件时访问远程控制台端口：

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

./client -u Username -p Password

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

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

默认情况下启用 JMX 端口，并通过 JAAS 身份验证进行保护。若要访问 JMX 端口，您必须至少有一个登录凭证配置有一组登录凭证。要连接到 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 Camel OSGi archetype 创建了一个项目，用于构建可部署到 OSGi 容器中的路由。

以下示例演示了如何使用 Maven archetype 命令和 GroupId:ArtifactId: Version:Version 来生成 camel-blueprint 项目。

mvn archetype:generate \
 -DarchetypeGroupId=org.apache.camel.archetypes \
 -DarchetypeArtifactId=camel-archetype-blueprint \
 -DarchetypeVersion=2.23.2.fuse-7_11_1-00015-redhat-00002

运行此命令后，Maven 会提示您指定 GroupId、ArtifactId 和版本。

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

mvn install

该命令的作用是编译所有 Java 源文件，以在 ArtifactId/target 目录下生成 bundle JAR，然后在本地 Maven 存储库中安装生成的 JAR。

如果您已有 Maven 项目并想对其进行修改，以便其生成 OSGi 捆绑包，请执行以下步骤：

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

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

此设置的影响是选择 Maven bundle 插件 maven-bundle-plugin 来为此项目执行打包。但是，此设置本身无效，直到将捆绑包插件显式添加到您的 POM 之前才会生效。

要添加 Maven bundle 插件，请将以下示例 插件 元素复制并粘贴到项目的 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>

这里的 bundle 插件由 instructions 元素中的设置配置。

有关为 Apache CXF 配置捆绑插件的某些具体建议，请参阅 第 5.3 节 “在捆绑包中打包 Web 服务”。

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

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

<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 项目，以便项目生成适合在红帽 Fuse OSGi 容器中部署的 OSGi 捆绑包。要转换 Maven 项目，您需要修改项目的 POM 文件和项目的蓝图文件（位于 META-INF/spring中）。

要配置 Maven POM 文件来生成捆绑包，您需要进行两种更改：更改 POM 的软件包类型到 捆绑包 ；并将 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 元素内以逗号分隔列表的形式出现。请注意通配符(1)的外观，即，作为列表的最后一个元素。通配符确保扫描当前捆绑包中的 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-first 方法开发您的服务，如下所示：

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

有关如何使用 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 Service Unit 的捆绑包，在控制台提示中输入 bundle:list 可能会生成类似如下的输出：

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

现在，您可以通过输入以下控制台命令使用 ID 181 来卸载捆绑包：

bundle:uninstall 181

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

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

OSGI-INF/blueprint

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

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

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

蓝图配置的根元素是 蓝图，因此蓝图 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 标头的值是一个分号隔开的列表，其中第一个项目是实际捆绑包符号名称，第二个项目是 蓝图。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 示例引用的帐户 类可以定义如下：

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 “The HelloWorldSvcImpl Class” 添加到其中。

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 配置文件是一个 XML 文件，存储在类路径上的 OSGI-INF/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 的 root 范围内。

例 12.5 “用于导出服务的蓝图文件” 显示了一个示例 Blueprint 文件，该文件使用 bean 元素创建 HelloWorldSvc 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>

其中 参考 元素会创建一个参考管理器，该管理器在 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 “Client Class” 添加 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 类为 helloWorldS vcan 属性定义一个 getter 和 setter 方法，它可以通过注入来接收 Hello World 服务的引用。init（） 方法在 bean 初始化阶段调用，在属性注入后，这通常可以在此方法范围内调用 Hello World 服务。

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

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

当将 Apache Camel 路由部署到 OSGi 容器时，CamelContext 会自动设置 registry 链以解析 Bean 实例：registry 链由 OSGi 注册表组成，然后是 Blueprint 注册表。现在，如果您尝试引用特定的 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 的语法是 file:PathName，其中 PathName 是 Classpath 上提供的文件的相对或绝对路径名称。提供的 PathName 由 Java 的内置文件 URL 处理程序 解析。因此，PathName 语法在 Windows 上受到 Java 路径名称的一般约定：特别是 Windows，每个反斜杠都必须被另一个反斜杠转义，或者替换为正斜杠。

例如，考虑 Windows 上的路径名称，C:\Projects\camel-bundle\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 handler 方案来定位捆绑包。

Mvn URL 具有以下语法：

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

其中 repositoryUrl optionally 指定 Maven 存储库的 URL。groupId、artifactId、版本、打包和 分类器 是标准的 Maven 协调，用于查找 Maven 工件。

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

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

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

要指定 分类器 值而不指定 打包 或 版本 值，可以在 Mvn URL 中造成差距。同样，如果您想要指定没有 版本 值的 打包 值。例如：

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

当在 Mvn URL 中指定 version 值时，您可以指定一个版本范围（使用标准 Maven 版本范围语法）以代替简单的版本号。您可以使用方括号[ 和 ]- 表示带括号和括号（ 和 ）- 以表示独占范围。例如，范围 [1.0.4,2.0） 匹配任何版本 v，它们满足 1.0.4 busybox 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 artifiact。如果解析 Mvn URL 出现问题，您应该首先检查处理程序设置，以查看使用哪个本地存储库和远程存储库来解析 URL。

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

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

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.11.1.fuse-7_11_1-00013-redhat-00003/system@snapshots@id=karaf.system,file:/home/userid/.m2/repository@snapshots@id=local,file:/path/to/JBossFuse/jboss-fuse-7.11.1.fuse-7_11_1-00013-redhat-00003/local-repo@snapshots@id=karaf.local-repo,file:/path/to/JBossFuse/jboss-fuse-7.11.1.fuse-7_11_1-00013-redhat-00003/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.11.1.fuse-7_11_1-00013-redhat-00003/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.11.1.fuse-7_11_1-00013-redhat-00003/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 Protocol 文档。

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

Wrap URL 具有以下语法：

wrap:locationURL[,instructionsURL][$instructions]

locationURL 可以是找到 JAR 的任何 URL（引用的 JAR 不会 作为捆绑包的格式）。可选的 instructionsURL 引用了一个 Bnd 属性文件，用于指定如何执行捆绑包转换。可选的 指令是 符号、和，由 Bnd 属性列表指定如何执行捆绑包转换。

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

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

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

以下 Wrap URL 使用来自文件的 Bnd 属性，E:\Data\Examples\commons-logging-1.1.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 文件自动添加必需的清单标头到 WAR 文件，如下所述。

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

war:warURL
warref:instructionsURL

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

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

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

默认情况下，War URL 处理程序将清单标头添加到 WAR 的 META-INF/Manifest.mf 文件中，如 表 15.2 “Wrapping a 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 将 wicket -examples-1.4.7.bnd 文件中的 WAR 属性引用 WAR 文件，然后使用 .bnd 文件中的其他指令将 WAR 转换成 OSGi 捆绑包：

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

有关 war URL 语法的详情，请查看原始 Pax URL War Protocol 文档。

自 PAXWEB-1255 起，可以更改监听器使用的 XNIO worker 和缓冲池的配置。在 undertow.xml 模板中有一个指定某些与 IO 相关参数的默认值的部分：

<!-- Only "default" worker and buffer-pool are supported and can be used to override the default values used by all listeners
    buffer-pool:
     - buffer-size defaults to:
        - when < 64MB of Xmx: 512
        - when < 128MB of Xmx: 1024
        - when >= 128MB of Xmx: 16K - 20
     - direct-buffers defaults to:
        - when < 64MB of Xmx: false
        - when >= 64MB of Xmx: true
    worker:
     - io-threads defaults to Math.max(Runtime.getRuntime().availableProcessors(), 2);
     - task-core-threads and task-max-threads default to io-threads * 8
-->

<!--
<subsystem xmlns="urn:jboss:domain:io:3.0">
    <buffer-pool name="default" buffer-size="16364" direct-buffers="true" />
    <worker name="default" io-threads="8" task-core-threads="64" task-max-threads="64" task-keepalive="60000" />
</subsystem>
-->

可以指定以下 buffer-pool 参数：

可指定以下 worker 参数：

可以在每个服务或捆绑包的基础上配置 Undertow 线程池及其名称，这有助于从 Hawtio 控制台进行监控并更有效地调试。

在捆绑包蓝图配置文件中（通常存储在 Maven 项目中的 src/main/resources/OSGI-INF/blueprint 目录下），您可以像以下示例所示配置 workerIOName 和 ThreadPool。

<httpu:engine-factory>
    <httpu:engine port="9001">
        <httpu:threadingParameters minThreads="99" maxThreads="777" workerIOThreads="8" workerIOName="WorkerIOTest"/>
    </httpu:engine>
</httpu:engine-factory>

可指定 以下线程参数 ：

可指定以下 worker 参数：

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

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 包含 功能 作为范围，列表 为 name。

OSSM"groups"按范围表示命令。每个范围都组成一个子 shell。

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

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

或在子 shell 中输入命令并键入命令上下文到子 shell：

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

您可以通过键入 subshell 名称（以下特性）直接在子 shell 中输入。您可以从子 shell 直接"切换"到另一个：

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

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

exit 命令进入父子 shell:

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

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

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

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

completionMode = GLOBAL

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

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

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

GLOBAL completion 模式是 CIB 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 completion 模式是 GLOBAL completion 模式的替代模式。

如果在根级别子 shell 中键入 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 补全模式是真正的子 shell 模式。

如果在 root 级别上键入 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)安全机制。这意味着，根据连接到控制台的用户，您可以根据用户的组和角色定义、执行某些命令的权限，或者限制参数允许的值。

控制台 安全性在本指南的安全部分 进行了详细。

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

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

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

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

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

通常，应用程序需要配置（请参阅用户指南中的 [Configuration 部分| 配置]）。因此，在除了依赖捆绑包外，还需要创建或部署配置，然后才能启动您的应用程序。

正如我们看到的那样，应用程序的配置可能非常长且非常快。

Apache Karaf 提供简单而灵活的方式来置备应用程序。

在 Apache Karaf 中，应用程序调配是一个 Apache Karaf "feature"。

功能描述了应用程序：

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

功能解析器检查服务要求，并安装提供与要求匹配的服务的捆绑包。默认模式只为"new 风格"功能存储库启用此行为（基本来说，模式的功能库 XML 等于 1.3.0）。它不适用于"旧风格"功能存储库（与 Karaf 2 或 3 起）。

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

serviceRequirements=default

可能的值有：

另外，一个功能也可以定义要求。在这种情况下，Bill 可以自动进行额外的捆绑包或功能，从而满足要求。

功能具有完整的生命周期：安装、启动、停止、更新、卸载。

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

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

例如，以下 XML 文件（或"功能存储库"）描述了 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 的功能带有 schema。查看详情的用户指南的 [Features XML Schema 部分|provisioning-schema]。feature1 功能在版本 1.0.0 中提供，它包含两个捆绑包。& lt;bundle /> 元素包含捆绑包工件的 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 注册功能存储库。

功能状态存储在 Apache Karaf 缓存中（在 KARAF_DATA 文件夹中）。您可以重启 Apache Karaf，之前安装的功能会在重启后保留安装且可用。如果您进行一个干净的重启，或者删除 Apache Karaf 缓存（删除 KARAF_DATA 文件夹），则之前安装的所有功能存储库都将丢失：您必须再次注册功能并再次安装功能。要防止这种行为，您可以将功能指定为引导功能。

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

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 将 overide 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 部分|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 repositories 和 URL|urls]）。

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

您可以通过直接将文件拖放 在部署 文件夹中，"热部署"功能 XML。

Apache Karaf 提供了功能部署器。

当您丢弃部署文件夹中的功能 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=*.

当您以默认模式或在 第 2.1.3 节 “以服务器模式启动运行时” 中启动 Red Hat Fuse 运行时，它会启用可从任何其他 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 中。

例 18.1 “标准 Maven 目录布局” 展示了与构建 OSGi 捆绑项目相关的标准 Maven 目录布局的元素。另外，也会显示 Blueprint 配置文件（ 不由 Maven 定义）的标准位置。

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

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

pom.xml 文件是当前项目的 Project Object Model(POM)，其中包含有关如何构建当前项目的完整描述。pom.xml 文件可以完全包含，但频繁（用于更复杂的 Maven 项目）；它可以从 父 POM 文件导入设置。

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

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

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

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

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

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

每个 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/blueprint/*.xml 来启用它。有关 Blueprint 容器的详情，请参考 第 12 章 OSGi 服务。

log:clear 命令清除日志条目。

log:display 命令显示日志条目。

默认情况下，它显示 rootLogger 的日志条目：

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

您还可以使用 logger 参数显示特定日志记录器的日志条目：

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

默认情况下会显示所有日志条目。如果从长时间运行 Apache Karaf 容器，这可能非常长。您可以使用 -n 选项限制要显示的条目数量：

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

您还可以使用 etc/org.apache.karaf.log.cfg 文件中的 size 属性限制存储和保留的条目数量：

#
# 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

默认情况下，每个日志级别都以不同的颜色显示： ERROR/FATAL，代表代表，FATA 为红色，以 purple、INFO in cyan 等。您可以使用 --no-color 选项禁用颜色。

日志条目格式模式不使用 etc/org.ops4j.pax.logging.cfg 文件中定义的转换模式。默认情况下，它使用 etc/org.apache.karaf.log.cfg 中定义的 pattern 属性。

#
# 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

您还可以使用 -p 选项动态更改模式（对于一个执行）：

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

这个模式是一个常规的 Log4j2 模式，您可以使用关键字（如 %d 代表日期），%c 代表类，%m 作为日志消息。

log:exception-display 命令显示最后一次发生异常的情况。

对于 log:display 命令，log:exception-display 命令默认使用 rootLogger，但您可以使用 logger 参数指定一个 日志记录器。

log:get 命令显示日志记录器的当前日志级别。

默认情况下，显示的日志级别是来自根日志记录器的日志级别：

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

您可以使用 logger 参数指定特定的 日志记录器 ：

karaf@root()> log:get ssh
INFO

logger 参数接受 ALL 关键字，以显示所有日志记录器的日志级别（作为列表）。

例如，如果您在 etc/org.ops4j.pax.logging.cfg 文件中定义了自己的日志记录器，如下所示：

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

log:list 命令是 log:get ALL 的别名。

log:log 命令允许您在日志中手动添加消息。在创建 Apache Karaf 脚本时，这很有趣的：

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

默认情况下，日志级别为 INFO，但您可以使用 -l 选项指定不同的日志级别：

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

log:set 命令设置日志记录器的日志级别。

默认情况下，它会更改 rootLogger 的日志级别：

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

您可以在 级别 后面使用 logger 参数指定特定的日志记录器：

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

level 参数接受任何 Log4j2 日志级别： abrt、DEBUG、INFOR、WARN、ERROR、FATAL。

它还接受 DEFAULT 特殊关键字。

DEFAULT 关键字的目的是删除日志记录器的当前级别（仅是级别，没有删除 appender 之类的其他属性），以使用日志记录器父项的级别（日志记录器是层次结构）。

例如，您已定义了以下日志记录器（在 etc/org.ops4j.pax.logging.cfg 文件中）：

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

您可以更改 my.logger.custom logger 的级别：

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

现在，我们已有：

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

您可以使用 my.logger.custom logger 中的 DEFAULT 关键字来删除该级别：

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

现在，我们已有：

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

这表示，在运行时，my.logger.custom 日志记录器使用其父 my.logger so INFO 的级别。

现在，如果我们将 DEFAULT 关键字与 my.logger 日志记录器搭配使用：

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

我们有：

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

因此，my.logger.custom 和 my.logger 都使用父 rootLogger 的日志级别。

通过将 DEFAULT 关键字与 rootLogger 一起使用，它没有父项。

log:tail 与 log:display 完全相同，但它持续显示日志条目。

您可以使用与 log:display 命令相同的选项和参数。

默认情况下，它显示 rootLogger 中的条目：

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:tail 命令中退出，只需按 CTRL-C 键。

Fuse-Karaf 提供 Log4j2 sift appender 的 Log4j2 sift appender 和一个日志记录器的示例（在 $FUSE_HOME/etc/org.ops4j.pax.ops4j.pax.logging.cfg 文件中：

# Sift appender
log4j2.appender.mdc.type = Routing
log4j2.appender.mdc.name = SiftAppender
log4j2.appender.mdc.routes.type = Routes
# see: http://logging.apache.org/log4j/2.x/manual/appenders.html#Routes
log4j2.appender.mdc.routes.pattern = $\\{ctx:bundle.name}
log4j2.appender.mdc.routes.sift.type = Route
log4j2.appender.mdc.routes.sift.appender.type = RollingRandomAccessFile
log4j2.appender.mdc.routes.sift.appender.name = RollingFile
log4j2.appender.mdc.routes.sift.appender.fileName = ${karaf.data}/log/sift-$\\{ctx:bundle.name}.log
log4j2.appender.mdc.routes.sift.appender.filePattern = ${karaf.data}/log/sift-$\\{ctx:bundle.name}-%i.log.gz
log4j2.appender.mdc.routes.sift.appender.append = true
log4j2.appender.mdc.routes.sift.appender.layout.type = PatternLayout
log4j2.appender.mdc.routes.sift.appender.layout.pattern = ${log4j2.pattern}
log4j2.appender.mdc.routes.sift.appender.policies.type = Policies
log4j2.appender.mdc.routes.sift.appender.policies.size.type = SizeBasedTriggeringPolicy
log4j2.appender.mdc.routes.sift.appender.policies.size.size = 16MB
log4j2.appender.mdc.routes.sift.appender.strategy.type = DefaultRolloverStrategy
log4j2.appender.mdc.routes.sift.appender.strategy.max = 20
...
# sample logger using Sift appender
#log4j2.logger.example.name = org.apache.camel
#log4j2.logger.example.level = INFO
#log4j2.logger.example.appenderRef.SiftAppender.ref = SiftAppender

配置在 http://logging.apache.org/log4j/2.x/manual/appenders.html#RoutingAppender中描述

SIFT/Routing appender 的 Pattern 属性是可用于区分日志的目标位置。

可用的查找有不同的查找，如下所述 ：http://logging.apache.org/log4j/2.x/manual/lookups.html

最重要的查找是 ctx one，它会在 ThreadContext 映射(a.k.a)中查找值（键）。MDC).

Fuse Karaf 提供的默认配置使用 ctx:bundle.name 作为模式，即：

lookup bundle.name key in MDC

bundle. prefix 键由 pax-logging 本身提供，有 3 个不同的值可供选择：

但是，如果使用 MDC 支持创建 Camel 上下文（蓝色打印 XML DSL）：

<camelContext id="my-context" xmlns="http://camel.apache.org/schema/blueprint" useMDCLogging="true">

在 MDC/ThreadContext 中会有一个更多密钥，然后将其用作 SIFT appender 配置中的模式：

请查看 https://people.apache.org/~dkulp/camel/mdc-logging.html

例如，若要通过 Camel 的路由 ID 来区分日志目标文件，请使用：

log4j2.appender.mdc.routes.pattern = $\\{ctx:camel.routeId}
...
log4j2.appender.mdc.routes.sift.appender.fileName = ${karaf.data}/log/sift-$\\{ctx:camel.routeId}.log
log4j2.appender.mdc.routes.sift.appender.filePattern = ${karaf.data}/log/sift-$\\{ctx:camel.routeId}-%i.log.gz

更多事情 - 仅附加器配置还不够 - 必须将其附加到某些日志记录器。同样，配置示例包含：

# sample logger using Sift appender
#log4j2.logger.example.name = org.apache.camel
#log4j2.logger.example.level = INFO
#log4j2.logger.example.appenderRef.SiftAppender.ref = SiftAppender

（注意，log4j2.logger.example.appenderRef.SiftAppender.ref 属性的值应与 appender configuration 中的 log4j2.appender.mdc.name 的值匹配。

在这里，org.apache.camel 是日志记录器名称（或类别名称）。这完全与 Camel 日志中使用的值完全相同：端点。因此，如果您已有（在 Camel 路由中）：

<to uri="log:org.apache.camel" />

日志记录可以正常工作。

另一个工作配置是：

<to uri="log:my-special-logger" />

和：

log4j2.logger.example.name = my-special-logger
log4j2.logger.example.level = DEBUG
log4j2.logger.example.appenderRef.SiftAppender.ref = SiftAppender

您可以将过滤器应用到 appender。过滤器评估每个日志事件，并确定是否将其发送到日志。

Log4j2 提供可用的过滤器。

嵌套的附加器是特殊的附加器，您可以使用 "inside" another appender。它允许您在一个附加器链之间创建某种"routing"。

最常用的"嵌套合规"附加器为：

这种附加器接受 appender 定义中的 appenders 属性：

log4j2.appender.[appender-name].appenders=[comma-separated-list-of-appender-names]

例如，您可以创建一个名为 async 的 AsyncAppender，异步将日志消息分配给 JMS 附加程序：

log4j2.appender.async=org.apache.log4j2.AsyncAppender
log4j2.appender.async.appenders=jms

log4j2.appender.jms=org.apache.log4j2.net.JMSAppender
...

有时，附加程序可能会失败。例如，RollingFileAppender 尝试写入文件系统，但文件系统已满，或者 JMS 附加程序尝试发送消息，但 JMS 代理不可用。

日志记录可能很重要，因此务必要知道日志附加程序是否失败。

每个日志附加程序可以将错误处理委托给错误处理程序，从而有机会响应附加程序错误。

您可以使用 appender 定义本身上的 errorhandler 属性定义您要用于每个 appender 的错误处理器：

log4j2.appender.[appender-name].errorhandler=[error-handler-class]
log4j2.appender.[appender-name].errorhandler.root-ref=[true|false]
log4j2.appender.[appender-name].errorhandler.logger-ref=[logger-ref]
log4j2.appender.[appender-name].errorhandler.appender-ref=[appender-ref]

路由 附加器是 OSGi 的附加程序，可让您根据 MDC(Mapped Diagnostic Context)属性分割日志事件。

MDC 允许您区分不同的日志事件来源。

路由 附加器默认提供面向 OSGi 的 MDC 属性：

您可以使用这些 MDC 属性为每个捆绑包创建日志文件：

log4j2.appender.routing.type = Routing
log4j2.appender.routing.name = Routing
log4j2.appender.routing.routes.type = Routes
log4j2.appender.routing.routes.pattern = $$\\{ctx:bundle.name\\}
log4j2.appender.routing.routes.bundle.type = Route
log4j2.appender.routing.routes.bundle.appender.type = RollingRandomAccessFile
log4j2.appender.routing.routes.bundle.appender.name = Bundle-$\\{ctx:bundle.name\}
log4j2.appender.routing.routes.bundle.appender.fileName = ${karaf.data}/log/bundle-$\\{ctx:bundle.name\\}.log
log4j2.appender.routing.routes.bundle.appender.filePattern = ${karaf.data}/log/bundle-$\\{ctx:bundle.name\\}.log.%d{yyyy-MM-dd}
log4j2.appender.routing.routes.bundle.appender.append = true
log4j2.appender.routing.routes.bundle.appender.layout.type = PatternLayout
log4j2.appender.routing.routes.bundle.appender.policies.type = Policies
log4j2.appender.routing.routes.bundle.appender.policies.time.type = TimeBasedTriggeringPolicy
log4j2.appender.routing.routes.bundle.appender.strategy.type = DefaultRolloverStrategy
log4j2.appender.routing.routes.bundle.appender.strategy.max = 31

log4j2.rootLogger.appenderRef.Routing.ref = Routing

默认情况下，Apache Karaf 提供特殊的堆栈跟踪器，可添加一些 OSGi 特定信息。

在堆栈跟踪中，除了引发异常的类外，您还可以在每个堆栈追踪行末尾找到模式 [id:name:version]，其中：

诊断问题源非常有用。

例如，在以下 IllegalArgumentException 堆栈追踪中，我们可以查看有关异常来源的 OSGi 详情：

java.lang.IllegalArgumentException: Command not found:  *:foo
	at org.apache.felix.gogo.runtime.shell.Closure.execute(Closure.java:225)[21:org.apache.karaf.shell.console:4.0.0]
	at org.apache.felix.gogo.runtime.shell.Closure.executeStatement(Closure.java:162)[21:org.apache.karaf.shell.console:4.0.0]
	at org.apache.felix.gogo.runtime.shell.Pipe.run(Pipe.java:101)[21:org.apache.karaf.shell.console:4.0.0]
	at org.apache.felix.gogo.runtime.shell.Closure.execute(Closure.java:79)[21:org.apache.karaf.shell.console:4.0.0]
	at org.apache.felix.gogo.runtime.shell.CommandSessionImpl.execute(CommandSessionImpl.java:71)[21:org.apache.karaf.shell.console:4.0.0]
	at org.apache.karaf.shell.console.jline.Console.run(Console.java:169)[21:org.apache.karaf.shell.console:4.0.0]
	at java.lang.Thread.run(Thread.java:637)[:1.7.0_21]

您可以在 Apache Karaf 中使用您自己的附加器。

最简单的方法是将您的附件程序打包为 OSGi 捆绑包，并将其作为 org.ops4j.pax.logging.pax-logging-service 捆绑包的片段附加。

例如，您要创建 MyAppender ：

public class MyAppender extends AppenderSkeleton {
...
}

您将编译并打包成包含 MANIFEST 的 OSGi 捆绑包：

Manifest:
Bundle-SymbolicName: org.mydomain.myappender
Fragment-Host: org.ops4j.pax.logging.pax-logging-service
...

将捆绑包复制到 Apache Karaf 系统 文件夹中。系统 文件夹使用标准的 Maven 目录布局：groupId/artifactId/version。

在 etc/startup.properties 配置文件中，您可以在 pax-logging-service 捆绑包前在列表中定义捆绑包。

要重新加载系统捆绑包，您必须通过清理一个干净运行（清除 data 文件夹）来重启 Apache Karaf。现在，您可以直接在 etc/org.ops4j.pax.logging.cfg 配置文件中使用附加程序。

正如我们看到的那样，默认情况下，Apache Karaf 使用 PropertiesLoginModule。

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

初始 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 层，chronyc 支持通过密钥进行身份验证，允许在不提供密码的情况下登录。

SSH 客户端（因此 bin/client 由 Karaf 本身提供），或者任何 ssh 客户端（如 OpenSSH）使用公钥/私钥对，它将标识自己在 Karaf SSHD（服务器端）上的 public/私钥对。

允许连接的密钥存储在 etc/keys.properties 文件中，其格式如下：

user=key,role

默认情况下，Packspace 允许 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.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*