<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" ...>
  
  <bean id="beanA" class="org.jboss.test.osgi.example.blueprint.bundle.BeanA">
    <property name="mbeanServer" ref="mbeanService"/>
  </bean>
  
  <service id="serviceA" ref="beanA" interface="org.jboss.test.osgi.example.blueprint.bundle.ServiceA">
  </service>
  
  <service id="serviceB" interface="org.jboss.test.osgi.example.blueprint.bundle.ServiceB">
    <bean class="org.jboss.test.osgi.example.blueprint.bundle.BeanB">
       <property name="beanA" ref="beanA"/>
    </bean>
  </service>
  
  <reference id="mbeanService" interface="javax.management.MBeanServer"/>

</blueprint>

@Test
public void testServiceA() throws Exception
{
  ServiceReference<ServiceA> srefA = context.getServiceReference(ServiceA.class);
  assertNotNull("ServiceA not null", srefA);
  
  ServiceA serviceA = context.getService(srefA);
  MBeanServer mbeanServer = serviceA.getMbeanServer();
  assertNotNull("MBeanServer not null", mbeanServer);

  ServiceReference<ServiceB> srefB = context.getServiceReference(ServiceB.class);
  assertNotNull("ServiceB not null", srefB);
  
  ServiceB serviceB = context.getService(sref);
  BeanA beanA = serviceB.getBeanA();
  assertNotNull("BeanA not null", beanA);
}

public void testManagedService() throws Exception {

   // Get the {@link Configuration} for the given PID
   Configuration config = configAdmin.getConfiguration(ConfiguredService.SERVICE_PID);
   assertNotNull("Config not null", config);

   Dictionary<String, String> configProps = new Hashtable<String, String>();
   configProps.put("foo", "bar");
   config.update(configProps);

   // Register a {@link ManagedService}
   Dictionary<String, String> serviceProps = new Hashtable<String, String>();
   serviceProps.put(Constants.SERVICE_PID, ConfiguredService.SERVICE_PID);
   bundlecontext.registerService(new String[] { ConfiguredService.class.getName(), 
      ManagedService.class.getName() }, new ConfiguredService(), serviceProps);

   // Wait a little for the update event
   if (latch.await(5, TimeUnit.SECONDS) == false)
      throw new TimeoutException();

   // Verify service property
   ServiceReference sref = bundlecontext.getServiceReference(ConfiguredService.class.getName());
   ConfiguredService service = (ConfiguredService) bundlecontext.getService(sref);
   assertEquals("bar", service.getValue("foo"));

   config.delete();
}

<component name="sample.component" immediate="true">
  <implementation class="org.jboss.test.osgi.example.ds.SampleComparator" />
  <property name="service.description" value="Sample Comparator Service" />
  <property name="service.vendor" value="Apache Software Foundation" />
  <service>
    <provide interface="java.util.Comparator" />
  </service>
</component>

public void testImmediateService() throws Exception {

  // Track the service provided by the test bundle
  final CountDownLatch latch = new CountDownLatch(1);
  ServiceTracker tracker = new ServiceTracker(context, Comparator.class.getName(), null) {
     public Object addingService(ServiceReference reference) {
         Comparator<Object> service = (Comparator<Object>) super.addingService(reference);
         latch.countDown();
         return service;
     }
  };
  tracker.open();

  // Wait for the service to become available
  if (latch.await(2, TimeUnit.SECONDS) == false)
    throw new TimeoutException("Timeout tracking Comparator service");
}

public void testEventHandler() throws Exception
{
  TestEventHandler eventHandler = new TestEventHandler();
  
  // Register the EventHandler
  Dictionary param = new Hashtable();
  param.put(EventConstants.EVENT_TOPIC, new String[Introduction] { TOPIC });
  context.registerService(EventHandler.class.getName(), eventHandler, param);

  // Send event through the the EventAdmin
  EventAdmin eventAdmin = EventAdminSupport.provideEventAdmin(context, bundle);
  eventAdmin.sendEvent(new Event(TOPIC, null));
  
  // Verify received event
  assertEquals("Event received", 1, eventHandler.received.size());
  assertEquals(TOPIC, eventHandler.received.get(0).getTopic());
}

ServiceReference<JNDIContextManager> sref = context.getServiceReference(JNDIContextManager.class);
JNDIContextManager contextManager = context.getService(sref);

Context initialContext = contextManager.newInitialContext();
BundleContext context = (BundleContext) initialContext.lookup("osgi:framework/bundleContext");
Assert.assertEquals(bundle.getBundleContext(), context);

public class MBeanActivator implements BundleActivator
{
   public void start(BundleContext context)
   {
      ServiceTracker tracker = new ServiceTracker(context, MBeanServer.class.getName(), null)
      {
         public Object addingService(ServiceReference reference)
         {
            MBeanServer mbeanServer = (MBeanServer)super.addingService(reference);
            registerMBean(mbeanServer);
            return mbeanServer;
         }

         @Override
         public void removedService(ServiceReference reference, Object service)
         {
            unregisterMBean((MBeanServer)service);
            super.removedService(reference, service);
         }
      };
      tracker.open();
   }

   public void stop(BundleContext context)
   {
      ServiceReference sref = context.getServiceReference(MBeanServer.class.getName());
      if (sref != null)
      {
         MBeanServer mbeanServer = (MBeanServer)context.getService(sref);
         unregisterMBean(mbeanServer);
      }
   }
   ...
}

public void testMBeanAccess() throws Exception
{
   // Provide MBeanServer support
   MBeanServer server = ManagementSupport.provideMBeanServer(context, bundle);

   // Start the test bundle
   bundle.start();

   ObjectName oname = ObjectName.getInstance(FooMBean.MBEAN_NAME);
   FooMBean foo = ManagementSupport.getMBeanProxy(server, oname, FooMBean.class);
   assertEquals("hello", foo.echo("hello"));
}

public void testBundleStateMBean() throws Exception
{
   MBeanServer server = ManagementSupport.provideMBeanServer(context, bundle);

   ObjectName oname = ObjectName.getInstance(BundleStateMBean.OBJECTNAME);
   BundleStateMBean bundleState =  ManagementSupport.getMBeanProxy(server, oname, BundleStateMBean.class);
   assertNotNull("BundleStateMBean not null", bundleState);

   TabularData bundleData = bundleState.listBundles();
   assertNotNull("TabularData not null", bundleData);
   assertFalse("TabularData not empty", bundleData.isEmpty());
}

    private BundleContext context;

    @Resource
    public void setContext(BundleContext context) {
        this.context = context;
    }

    private List<PaymentProvider> providers = new ArrayList<PaymentProvider>();

    @PostConstruct
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void start() {
        ServiceTracker tracker = new ServiceTracker(context, PaymentProvider.class.getName(), null) {

            @Override
            public Object addingService(ServiceReference reference) {
                PaymentProvider service = (PaymentProvider) super.addingService(reference);
                providers.add(service);
                return service;
            }

            @Override
            public void removedService(ServiceReference reference, Object service) {
                providers.remove(service);
                super.removedService(reference, service);
            }
        };
        tracker.open();
    }

@Stateless
@LocalBean
public class SimpleStatelessSessionBean implements Echo {

    @Resource
    BundleContext context;

    public String echo(String message) {
        if (context == null) 
           throw new IllegalStateException("BundleContext not injected");

        if (BUNDLE_SYMBOLICNAME.equals(message)) {
            Bundle bundle = getTargetBundle();
            return bundle.getSymbolicName();
        }
        ...
    }
}

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

HttpService httpService = (HttpService)tracker.getService();
if (httpService == null)
   throw new IllegalStateException("HttpService not registered");

Properties initParams = new Properties();
initParams.setProperty("initProp", "SomeValue");
httpService.registerServlet("/servlet", new EndpointServlet(context), initParams, null);
httpService.registerResources("/file", "/res", null);

        builder.addImportPackages("javax.xml.bind", "javax.xml.bind.annotation");
        builder.addImportPackages("javax.xml.datatype", "javax.xml.namespace");

        JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class...);
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        URL resURL = bundle.getResource("booking.xml");
        JAXBElement<CourseBooking> rootElement = unmarshaller.unmarshal(resURL.openStream());
        assertNotNull("root element not null", rootElement);

        EntityManagerFactory emf = null;
        try {
            ServiceReference<EntityManagerFactory> sref = context.getServiceReference(EntityManagerFactory.class);
            emf = context.getService(sref);

            Employee emp = new Employee();
            emp.setId(100);
            emp.setAddress("Sesame Street");
            emp.setName("Kermit");

            EntityManager em = emf.createEntityManager();
            em.persist(emp);

            emp = em.find(Employee.class, 100);
            Assert.assertNotNull("Employee not null", emp);

            em.remove(emp);

        } finally {
            if (emf != null) {
                emf.close();
            }
        }

Transactional txObj = new Transactional();

ServiceReference userTxRef = context.getServiceReference(UserTransaction.class.getName());
assertNotNull("UserTransaction service not null", userTxRef);

UserTransaction userTx = (UserTransaction)context.getService(userTxRef);
assertNotNull("UserTransaction not null", userTx);

userTx.begin();
try
{
   ServiceReference tmRef = context.getServiceReference(TransactionManager.class.getName());
   assertNotNull("TransactionManager service not null", tmRef);
   
   TransactionManager tm = (TransactionManager)context.getService(tmRef);
   assertNotNull("TransactionManager not null", tm);
   
   Transaction tx = tm.getTransaction();
   assertNotNull("Transaction not null", tx);
   
   tx.registerSynchronization(txObj);
   
   txObj.setMessage("Donate $1.000.000");
   assertNull("Uncommited message null", txObj.getMessage());
   
   userTx.commit();
}
catch (Exception e)
{
   userTx.setRollbackOnly();
}

assertEquals("Donate $1.000.000", txObj.getMessage());

class Transactional implements Synchronization
{
  public void afterCompletion(int status)
  {
     if (status == Status.STATUS_COMMITTED)
        message = volatileMessage;
  }
  
  ...      
}

public class InterceptorActivator implements BundleActivator
{
   public void start(BundleContext context)
   {
      LifecycleInterceptor publisher = new PublisherInterceptor();
      LifecycleInterceptor parser = new ParserInterceptor();
      
      // Add the interceptors, the order of which is handles by the service
      context.registerService(LifecycleInterceptor.class.getName(), publisher, null);
      context.registerService(LifecycleInterceptor.class.getName(), parser, null);
   }
}

public class ParserInterceptor extends AbstractLifecycleInterceptor
{
   ParserInterceptor()
   {
      // Add the provided output
      addOutput(HttpMetadata.class);
   }

   public void invoke(int state, InvocationContext context)
   {
      // Do nothing if the metadata is already available  
      HttpMetadata metadata = context.getAttachment(HttpMetadata.class);
      if (metadata != null)
         return;

      // Parse and create metadta on STARTING
      if (state == Bundle.STARTING)
      {
          VirtualFile root = context.getRoot();
          VirtualFile propsFile = root.getChild("/http-metadata.properties");
          if (propsFile != null)
          {
             log.info("Create and attach HttpMetadata");
             metadata = createHttpMetadata(propsFile);
             context.addAttachment(HttpMetadata.class, metadata);
          }
      }
   }
   ...
}

public class PublisherInterceptor extends AbstractLifecycleInterceptor
{
   PublisherInterceptor()
   {
      // Add the required input
      addInput(HttpMetadata.class);
   }

   public void invoke(int state, InvocationContext context)
   {
      // HttpMetadata is guaratied to be available because we registered
      // this type as required input
      HttpMetadata metadata = context.getAttachment(HttpMetadata.class);

      // Register HttpMetadata on STARTING 
      if (state == Bundle.STARTING)
      {
         String servletName = metadata.getServletName();

         // Load the endpoint servlet from the bundle
         Bundle bundle = context.getBundle();
         Class servletClass = bundle.loadClass(servletName);
         HttpServlet servlet = (HttpServlet)servletClass.newInstance();

         // Register the servlet with the HttpService
         HttpService httpService = getHttpService(context, true);
         httpService.registerServlet("/servlet", servlet, null, null);
      }

      // Unregister the endpoint on STOPPING 
      else if (state == Bundle.STOPPING)
      {
         log.info("Unpublish HttpMetadata: " + metadata);
         HttpService httpService = getHttpService(context, false);
         if (httpService != null)
            httpService.unregister("/servlet");
      }
   }
}

public class ResourceInjectionActivator implements BundleActivator {

    @Resource(name = "java:jboss/datasources/ExampleDS")
    public DataSource ds;

    public void start(BundleContext context) throws Exception {
        String productName = ds.getConnection().getMetaData().getDatabaseProductName();
        ...
    }
}

@Path("/rest")
@Consumes({ "application/json" })
@Produces({ "application/json" })
public class SimpleRestEndpoint {

    private static final Logger log = Logger.getLogger(SimpleRestEndpoint.class);

    @Resource
    private BundleContext context;

    @GET
    @Path("/echo/{message}")
    public String echo(@PathParam("message") String message) {
        ServiceReference<Echo> sref = context.getServiceReference(Echo.class);
        return context.getService(sref).echo(message);
    }
}

<web-app xmlns="http://java.sun.com/xml/ns/javaee" ... version="2.5">

  <display-name>WebApp Sample</display-name>

  <servlet>
    <servlet-name>servlet</servlet-name>
    <servlet-class>org.jboss.test.osgi.example.webapp.bundle.EndpointServlet</servlet-class>
    <init-param>
      <param-name>initProp</param-name>
      <param-value>SomeValue</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>servlet</servlet-name>
    <url-pattern>/servlet</url-pattern>
  </servlet-mapping>

</web-app>

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-SymbolicName: example-webapp
Bundle-ClassPath: .,WEB-INF/classes
Web-ContextPath: example-webapp
Import-Package: javax.servlet,javax.servlet.http,...

public void testServletAccess() throws Exception
{
   // Provide WebApp support
   WebAppSupport.provideWebappSupport(context, bundle);
        
   // Start the test bundle
   bundle.start();
        
   String line = getHttpResponse("/example-webapp/servlet?test=plain", 5000);
   assertEquals("Hello from Servlet", line);
}

DocumentBuilderFactory factory = XMLParserSupport.provideDocumentBuilderFactory(context, bundle);
factory.setValidating(false);

DocumentBuilder domBuilder = factory.newDocumentBuilder();
URL resURL = context.getBundle().getResource("example-xml-parser.xml");
Document dom = domBuilder.parse(resURL.openStream());
assertNotNull("Document not null", dom);

SAXParserFactory factory = XMLParserSupport.provideSAXParserFactory(context, bundle);
factory.setValidating(false);

SAXParser saxParser = factory.newSAXParser();
URL resURL = context.getBundle().getResource("example-xml-parser.xml");

SAXHandler saxHandler = new SAXHandler();
saxParser.parse(resURL.openStream(), saxHandler);
assertEquals("content", saxHandler.getContent());