Absolutely you can convert your annotation-based Spring Boot application into a Spring-driven OSGi Bundle—this is totally feasible with targeted adjustments to how your app handles context initialization, dependencies, and OSGi-specific behaviors. Let’s break down the key steps and considerations:

1. Swap Spring Boot's Default Context for an OSGi-Aware Annotation-Driven Context #

You mentioned Spring DM's OsgiBundleXmlApplicationContext for XML-configured bundles, but there’s no need to abandon annotations. Spring DM (and its successor, Spring OSGi) supports annotation-based configuration with variants like OsgiBundleAnnotationApplicationContext.

Instead of relying on Spring Boot’s auto-bootstrapped context, you’ll initialize this OSGi-aware context manually, typically via a BundleActivator:

public class MyBundleActivator implements BundleActivator {
    private OsgiBundleAnnotationApplicationContext context;

    @Override
    public void start(BundleContext bundleContext) throws Exception {
        context = new OsgiBundleAnnotationApplicationContext();
        context.setBundleContext(bundleContext);
        // Scan your annotation-based configuration classes
        context.register(MySpringConfig.class);
        context.refresh();
    }

    @Override
    public void stop(BundleContext bundleContext) throws Exception {
        if (context != null) {
            context.close();
        }
    }
}

Make sure your MySpringConfig uses standard Spring annotations like @Configuration, @ComponentScan, @Bean—Spring DM will recognize these alongside OSGi-specific annotations.

2. Tune Spring Boot Auto-Configuration for OSGi #

Spring Boot’s auto-configuration is optimized for standalone JVM apps, so you’ll need to exclude auto-configurations that conflict with OSGi:

• Embedded web servers: If you’re targeting a Web OSGi Bundle, exclude auto-configs like EmbeddedWebServerFactoryAutoConfiguration (since OSGi containers like Apache Karaf provide the HTTP server).
• Standalone-specific features: Exclude things like DataSourceAutoConfiguration if you’re using OSGi-managed data sources instead.

Use @SpringBootApplication with exclusions, or switch to a pure @Configuration setup if you don’t need all Spring Boot features:

@SpringBootApplication(exclude = {
    EmbeddedWebServerFactoryAutoConfiguration.class,
    DataSourceAutoConfiguration.class
})
@ComponentScan(basePackages = "com.yourpackage")
public class MySpringConfig {
    // Your bean definitions here
}

3. Configure OSGi Packaging & Dependencies #

OSGi requires a valid MANIFEST.MF with metadata like Bundle-SymbolicName, Import-Package, Export-Package, and Bundle-Activator. Use the Maven Bundle Plugin (or Gradle’s equivalent) to generate this automatically:

Add this to your pom.xml:

<plugin>
    <groupId>org.apache.felix</groupId>
    <artifactId>maven-bundle-plugin</artifactId>
    <version>4.2.1</version>
    <extensions>true</extensions>
    <configuration>
        <instructions>
            <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName>
            <Bundle-Version>${project.version}</Bundle-Version>
            <Bundle-Activator>com.yourpackage.MyBundleActivator</Bundle-Activator>
            <Import-Package>
                org.springframework.*,
                org.osgi.*,
                com.yourpackage.dependencies.*
            </Import-Package>
            <Export-Package>com.yourpackage.api.*</Export-Package>
        </instructions>
    </configuration>
</plugin>

Note: Avoid using Spring Boot’s fat jar packaging—OSGi requires dependencies to be separate Bundles managed by the OSGi container. Ensure all your dependencies are OSGi-compliant (have valid MANIFEST.MF entries); if not, you can wrap non-compliant jars in OSGi bundles using tools like Apache Karaf’s wrap: command.

4. Use OSGi-Specific Annotations Where Needed #

While most Spring annotations work as-is, you’ll need OSGi-specific annotations for interactions with the OSGi framework:

• Use @OsgiService to inject OSGi services from other bundles (instead of @Autowired for OSGi-managed beans).
• Use @BundleContext to inject the OSGi BundleContext directly into your beans.
• Use @Service (from Spring DM) to expose your Spring beans as OSGi services to other bundles:

@Component
@Service(MyService.class) // Exposes this bean as an OSGi service
public class MyServiceImpl implements MyService {
    @BundleContext
    private BundleContext bundleContext;

    @OsgiService
    private AnotherOsgiService externalService;

    // Your business logic here
}

5. Test in an OSGi Container #

Deploy your converted bundle to a mature OSGi container like Apache Karaf (which has excellent support for Spring DM/Spring OSGi). Karaf provides tools to:

• Install and start your bundle via the console (install file:///path/to/your/bundle.jar → start <bundle-id>).
• Check bundle status (bundle:list), service registrations (service:list), and logs (log:tail) to debug any issues.

• Spring Boot Features: Not all Spring Boot features translate seamlessly to OSGi. For example, Actuator endpoints may require additional configuration to work with OSGi’s web container, and DevTools is generally not recommended for OSGi bundles.
• Dependency Management: Ensure all transitive dependencies are available as OSGi bundles in your container. Karaf has a large repository of pre-packaged OSGi bundles for common libraries.

内容的提问来源于stack exchange，提问作者Jayant Mishra