为了帮助您快速启动，您可以调用 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 捆绑包，请执行以下步骤： 第 5.2.2 节 “将软件包类型改为捆绑包” 。 第 5.2.3 节 “将捆绑包插件添加到您的 POM” . 第 5.2.4 节 “自定义 bundle 插件” 。 第 5.2.5 节 “自定义 JDK 编译器版本” 。

通过将软件包类型更改为捆绑到项目的 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 方法开发您的服务，如下所示： java -first 方法 - 使用 cxf-java2ws-plugin 插件。 WSDL-first 方法 - 使用 cxf-codegen-plugin 插件。

OSGi 配置管理服务定义了将配置设置传递给 OSGi 捆绑包的机制。您不必使用此服务进行配置，但它通常是配置捆绑包应用程序的最便捷方式。蓝图提供对 OSGi 配置的支持，可让您使用从 OSGi 配置管理员服务获取的值替换 Blueprint 文件中的变量。 有关如何使用 OSGi 配置属性的详情，请参考 第 5.3.7 节 “配置捆绑插件” 和 第 9.6 节 “在功能中添加 OSGi 配置” 。

PID 字符串（symbolic-name 语法）允许在 OSGI 规格中允许连字符。但是，连字符由 Apache Felix.fileinstall 和 config:edit shell 命令解释，以区分"托管服务"和"托管服务工厂"。因此，建议您不要在 PID 字符串的其他位置使用连字符。 配置文件名称与 PID 和 factory 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 列表，用于指定要部署的每个捆绑包的位置。支持以下命令参数： 安装后启动捆绑包。

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 方案，其中包括以下方案类型： 第 15.1 节 “文件 URL 处理程序” . 第 15.2 节 “HTTP URL 处理程序” 。 第 15.3 节 “mvn URL Handler” 。

本质上，通过将新功能元素添加到一种特殊 XML 文件（称为 功能存储库）来创建一个功能 。 要创建功能，请执行以下步骤： 第 9.2 节 “创建自定义功能存储库” . 第 9.3 节 “为自定义功能存储库添加功能” . 第 9.4 节 “将本地存储库 URL 添加到功能服务中” 。 第 9.5 节 “在功能中添加依赖功能” . 第 9.6 节 “在功能中添加 OSGi 配置” 。

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

<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 安装 - Maven 是一个来自 Apache 的免费开源构建工具。您可以从 http://maven.apache.org/download.html 下载最新版本（最小为 2.0.9）。 互联网连接 -whilst 执行构建，Maven 会动态搜索外部存储库，并即时下载所需的工件。要使此任务正常工作，构建 机器必须 连接到互联网。

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 ，包含所生成项目的文件。 请注意 ，不要 为您的工件选择一个组 ID，该 ID 与现有产品的组 ID 冲突！ 这可能会导致项目的软件包和现有产品中的软件包与来自现有产品的软件包之间的冲突（因为组 ID 通常被用作项目 Java 软件包名称的根目录）。

您必须自定义 POM 文件才能生成 OSGi 捆绑包，如下所示： 按照 第 5.1 节 “生成捆绑包项目” 中描述的 POM 自定义步骤操作。 在 Maven bundle 插件的配置，修改捆绑包指令以导出 org.fusesource.example.service 软件包，如下所示：

<project ... >
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
          <instructions>
            <Bundle-SymbolicName>${pom.groupId}.${pom.artifactId}</Bundle-SymbolicName>
        <Export-Package>org.fusesource.example.service</Export-Package>
          </instructions>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

创建 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 项目，请执行以下步骤： 构建项目 - 打开命令提示并将目录更改为 ProjectDir /osgi-service 。使用以下命令构建演示：

mvn install

如果此命令成功运行，则 ProjectDir /osgi-service/target 目录应包含捆绑包文件 osgi-service-1.0-SNAPSHOT.jar 。 在 Red Hat Fuse 控制台中安装 并启动 osgi-service 捆绑包 ，请输入以下命令：

Jkaraf@root()> bundle:install -s file:ProjectDir/osgi-service/target/osgi-service-1.0-SNAPSHOT.jar

其中 ProjectDir 是包含 Maven 项目的目录，而 -s 标志会指示容器立即启动捆绑包。例如，如果您的项目目录是 Windows 机器上的 C:\Projects ，则使用以下命令：

karaf@root()> bundle:install -s file:C:/Projects/osgi-service/target/osgi-service-1.0-SNAPSHOT.jar

karaf@root()> bundle:list

[ 236] [Active     ] [Created     ] [       ] [   60] osgi-service (1.0.0.SNAPSHOT)

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

要使用 Maven Quickstart archetype 生成项目，您必须满足以下条件： Maven 安装 - Maven 是一个来自 Apache 的免费开源构建工具。您可以从 http://maven.apache.org/download.html 下载最新版本（最小为 2.0.9）。 互联网连接 -whilst 执行构建，Maven 会动态搜索外部存储库，并即时下载所需的工件。要使此任务正常工作，构建 机器必须 连接到互联网。

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 ，其中包含生成的项目的文件。 请注意 ，不要 为您的工件选择一个组 ID，该 ID 与现有产品的组 ID 冲突！ 这可能会导致项目的软件包和现有产品中的软件包与来自现有产品的软件包之间的冲突（因为组 ID 通常被用作项目 Java 软件包名称的根目录）。

您必须自定义 POM 文件才能生成 OSGi 捆绑包，如下所示： 按照 第 5.1 节 “生成捆绑包项目” 中描述的 POM 自定义步骤操作。 由于客户端使用 HelloWorldSvc Java 接口（在 osgi-service 捆绑包中定义），因此需要对 osgi-service 捆绑包添加 Maven 依赖项。假设 osgi-service 捆绑包的 Maven 协调为 org.fusesource.example:osgi-service:1.0-SNAPSHOT ，您应该在客户端的 POM 文件中添加以下依赖关系：

<project ... >
  <dependencies>
    <dependency>
        <groupId>org.fusesource.example</groupId>
        <artifactId>osgi-service</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
</project>

要将 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 项目，请执行以下步骤： 构建项目 - 打开命令提示并将目录更改为 ProjectDir /osgi-client 。使用以下命令构建演示：

mvn install

如果此命令成功运行，则 ProjectDir /osgi-client/target 目录应包含捆绑包文件 osgi-client-1.0-SNAPSHOT.jar 。 在 Red Hat Fuse 控制台中安装 并启动 osgi-service 捆绑包 ，请输入以下命令：

karaf@root()> bundle:install -s file:ProjectDir/osgi-client/target/osgi-client-1.0-SNAPSHOT.jar

其中 ProjectDir 是包含 Maven 项目的目录，而 -s 标志会指示容器立即启动捆绑包。例如，如果您的项目目录是 Windows 机器上的 C:\Projects ，则使用以下命令：

karaf@root()> bundle:install -s file:C:/Projects/osgi-client/target/osgi-client-1.0-SNAPSHOT.jar

Bundle ID: 239
OSGi client started.
Calling sayHello()
Hello World!

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

当将 Apache Camel 路由部署到 OSGi 容器时， CamelContext 会自动设置 registry 链以解析 Bean 实例：registry 链由 OSGi 注册表组成，然后是 Blueprint 注册表。现在，如果您尝试引用特定的 bean 类或 bean 实例，registry 会按如下方式解析 bean： 首先查找 OSGi 注册表中的 bean。如果指定了类名称，请尝试将其与 OSGi 服务的接口或类匹配。 如果在 OSGi 注册表中找不到匹配项，请重新回退到 Blueprint 注册表中。

考虑由以下 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 集成 。 当您使用此方法时，IOSGi 服务会被隐式导入。在这种情况下， 不需要 显式导入 OSGi 服务。

在 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 处理程序可以找到本地和远程 Maven 工件，您可能会发现需要它来自定义 Mvn URL 处理程序配置。详情请查看 第 15.3.5 节 “配置 Mvn URL 处理程序” 。

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 处理程序设置，如下所示： 第 15.3.6 节 “检查 Mvn URL 设置” . 第 15.3.7 节 “编辑配置文件” . 第 15.3.8 节 “自定义本地存储库的位置” .

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 处理程序 的详情，请查看以下引用： 有关 Bnd 属性和 Bnd 指令文件的详情，请参阅 Bnd 工具文档 。 原始 Pax URL Wrap Protocol 文档。

如果您需要在 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 文档。

当您以默认模式或在 第 2.1.3 节 “以服务器模式启动运行时” 中启动 Red Hat Fuse 运行时，它会启用可从任何其他 Fuse 控制台访问的远程控制台。远程控制台提供本地控制台的所有功能，并允许远程用户对容器及其内部运行的服务进行完全控制。 在 第 2.1.4 节 “以客户端模式启动运行时” 中运行时，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
        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
						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 个不同的值可供选择： bundle.name == org.osgi.framework.Bundle.getSymbolicName() bundle.id == org.osgi.framework.Bundle.getBundleId() bundle.version == org.osgi.framework.Bundle.getVersion().toString() 但是，如果使用 MDC 支持创建 Camel 上下文（蓝色打印 XML DSL）：

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

在 MDC/ThreadContext 中会有一个更多密钥，然后将其用作 SIFT appender 配置中的模式： Camel.exchangeId - 交换 ID Camel.messageId - 消息 ID Camel.correlationId - 与交换的关联 ID。例如，来自 Splitter EIP 的子消息 Camel.transactionKey - 转换交换的事务 ID。请注意 id 不是唯一的，而是其事务模板的 id，用于标记给定事务的事务边界。因此，我们决定将密钥命名为 transactionKey，而不是 transactionID 表明这一事实。 Camel.routeId - 路由的 id，当前正在路由。 Camel.breadcrumbId - 用于跨传输跟踪消息的唯一 ID。 Camel.contextId - 用于跟踪来自不同 camel 上下文的消息的 camel 上下文。 请查看 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 提供可用的过滤器。 请参阅 Log4J 站点上的 过滤器 ，以获得到其中的综合视图。

嵌套的附加器是特殊的附加器，您可以使用 "inside" another appender。它允许您在一个附加器链之间创建某种"routing"。 最常用的"嵌套合规"附加器为： AsyncAppender( org.apache.log4j2.AsyncAppender )会异步记录事件。此附加程序收集事件并将其分配到附加的所有附加者。 RewriteAppender( org.apache.log4j2.rewrite.RewriteAppender )在可能重新编写日志事件后将日志消息转发到另一个附加程序。 这种附加器接受 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 代理不可用。 日志记录可能很重要，因此务必要知道日志附加程序是否失败。 每个日志附加程序可以将错误处理委托给错误处理程序，从而有机会响应附加程序错误。 FailoverAppender( org.apache.log4j2.varia.FailoverAppender )允许在主附加程序失败时接管辅助附加程序。错误消息打印在 System.err 上，并记录在辅助附加程序中。 有关 FailoverAppender 的更多信息，请转至 Log4j2 的 Apppender Page 。 您可以使用 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 属性： bundle.id 是捆绑包 ID bundle.name 是捆绑包符号名称 bundle.version 是捆绑包版本 您可以使用这些 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] ，其中： id 是捆绑包 ID name 是捆绑包名称 版本是捆绑包版本 诊断问题源非常有用。 例如，在以下 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 配置文件允许您定义高级加密机制： encryption.prefix 属性将前缀定义为"flag"密码进行加密。默认值为 \{CRYPT\ }。 encryption.suffix 属性定义"flag"密码加密的后缀。默认值为 \{CRYPT\ }。 encryption.algorithm 属性定义用于加密的算法(digest)。可能的值有 MD2 、 MD5 、 SHA-1 、 SHA-256 、 SHA-384 、 SHA-512 。默认值为 MD5 。 encryption.encoding 属性定义加密密码的编码。可能的值有 十六进制 或 base64 。默认值为 十六进制 。

对于 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

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

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

bin/client -k ~/karaf.id_dsa

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

Apache Karaf 使用角色来控制对资源的访问：它是 RBAC（基于角色的访问控制）系统。 角色可用于控制： 了解 OSGi 服务 访问控制台（控制命令的执行） 访问 JMX（MBeans 和/或操作） 访问 WebConsole

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

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*