Chapter 8. Service Implementations

Procedure 8.1. Task

1. Create a new Bean Service Class in the SwitchYard Editor JBoss Developer Studio plug-in.
   Note

   If you provide the interface value first, it automatically generates default names for Name and Service Name.

   Figure 8.1. Creating a New Bean Service

   
   The example above shows ExampleBean as the name of the class and com.example.switchyard.docs.Example as the interface.
2. Click Finish.
   Your new class looks like this:

   package com.example.switchyard.docs;
    
   import org.switchyard.component.bean.Service;
    
   @Service(Example.class)
   public class ExampleBean implements Example {
   }
   

   The @Service annotation allows the SwitchYard CDI Extension to discover your bean at runtime and register it as a service. The value of the annotation (Example.class in the above example) represents the service contract for the service. Every bean service must have an @Service annotation with a value identifying the service interface for the service.
3. After creating a bean service, complete the service definition by adding one or more operations to the service interface and a corresponding implementation in your bean:

   package com.example.switchyard.docs;
    
   import org.switchyard.component.bean.Service;
    
   @Service(Example.class)
   public class ExampleBean implements Example {
    
      public void greet(Person person) {
          // implement service logic here for greet operation
      }
   }
   
   

Procedure 8.2. Task

• In order to provide a service with the Bean component, add an @Service annotation to your bean:

   @Service(SimpleService.class)
  public class SimpleServiceBean implements SimpleService {
     public String sayHello(String message) {
        System.out.println("*** Hello message received: " + message);
        return "Hi there!!";
     }  
  }
   
  public interface SimpleService {
     String sayHello(String message);
  }
  

  The SimpleService interface represents the Service Interface that defines the service operations exposed by SwitchYard.

Procedure 8.3. Task

• In order to consume a SwitchYard service from within a CDI bean, add a @Reference annotation to your bean:

  @Service(ConsumerService.class)
  public class ConsumerServiceBean implements ConsumerService {
   
    @Inject
    @Reference
     private SimpleService service;
   
     public void consumeSomeService() {
        service.sayHello("Hello");
     }  
  }
   
  public interface ConsumerService {
   
     void consumeSomeService();
  }
  

  By default, SwitchYard expects a service reference to be declared with a name which matches the Java type used for the reference. In the above example, the SimpleService type expects a service reference called "SimpleService" in your SwitchYard configuration. However, the @Reference annotation also accepts a service name if the service reference name does not match the Java type name of the contract. For example:

  @Reference("urn:myservices:purchasing:OrderService")
  private OrderService orders;

Procedure 8.4. Task

• To enable access to the invocation properties, add a Context property to your bean and annotate it with the CDI @Inject annotation:

  package com.example.switchyard.docs;
  
  import javax.inject.Inject;
  
  import org.switchyard.Context;
  import org.switchyard.component.bean.Service;
  @Service(SimpleService.class)
  public class SimpleServiceBean implements SimpleService {
   
  @Inject
  private Context context;
   
  public String sayHello(String message) {
          System.out.println("*** Funky Context Property Value: " + context.getPropertyValue("funkyContextProperty"));
          return "Hi there!!";
      }
  }
  

  Here, the Context interface allows your bean logic to get and set properties in the context.

  Note

  You can invoke the Context instance only within the scope of one of the Service Operation methods. If you invoke it outside this scope, it results in an UnsupportedOperationException error.

Procedure 8.5. Task

• To access the Implementation Properties, add an @Property annotation to your bean class identifying the property you want to inject:

  package com.example.switchyard.docs;
  
  import org.switchyard.component.bean.Property;
  import org.switchyard.component.bean.Service;
  
  @Service(SimpleService.class)
  public class SimpleServiceBean implements SimpleService {
  
      @Property(name="userName")
      private String name;
      
      @Override
      public String sayHello(String message) {
          return "Hello " + name + ", I got a message: " + message;
      }
  
  }
  

  Here, the @Property annotation is used for injecting the user.name property.