Chapter 9. Service Implementations

Procedure 9.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 9.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 9.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 9.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 9.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 9.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.

Procedure 9.6. Task

1. Create a new BPMN file in the SwitchYard Editor JBoss Developer Studio plug-in.
2. Input the values into the SwitchYard Editor's New SwitchYard BPMN File Screen.

   

   Figure 9.2. New SwitchYard BPMN File Screen

3. Click Finish.
   This creates a new service component definition for your process service and an empty BPMN process definition.
4. After creating a new BPM Service, create the BPMN 2 process definition and configure the BPM service component to interact with that process definition.

Procedure 9.7. Use Process Variables

1. Click on the white space around a process or on any of your process nodes.
2. Access the Properties view.
3. Declare the variablenames at the process level and in the Parameter Mapping (and possibly Result Mapping).

Procedure 9.8. 

1. Define your process using WS-BPEL within JBoss Developer Studio (with JBoss Integration and SOA Development tooling installed).
2. Define a WSDL interface for the BPEL service.
3. Define a Deployment Descriptor using the ODE Deployment Descriptor editor bundled with JBoss Tools.
4. Add the component containing the implementation and service interface to the SwitchYard configuration.

Procedure 9.9. Create a Camel Service

1. Create a new Camel Route file resource in the SwitchYard Editor JBoss Developer Studio plug-in.
2. Decide whether to use DSL or XML dialect for the route. (Functionally, they are more or less equivalent, the choice is determined by how you want to express your routing logic.)
3. If you want create a Java DSL route, select the "Camel (Java)" implementation type. For XML, use the "Camel (XML)" type.
4. Input the values into the SwitchYard Editor's New Route File Screen.
5. Click Finish.

1. You can use them to create a predicate in a message filter as shown below:

   public class ScriptingBuilder extends RouteBuilder
   {
   public void configure()
   {
   from("switchyard://Inbound").filter().javaScript("request.getHeader('myHeader') != null").to("switchyard://Outbound");
   }
   }

2. You can use them to implement your service using transform element as shown below:

   
   public class ScriptingImplementationBuilder extends RouteBuilder {
   public void configure()
   {
   from("switchyard://Inbound").transform().groovy("classpath:script.groovy"); 
   // classpath resource
   from("switchyard://InboundBsh").transform().language("beanshell", "file:script.bsh");
   // file system resource
   }
   }
   

Procedure 9.10. Create a Rules Service

1. Create a new SwitchYard Rules file in the SwitchYard Editor JBoss Developer Studio plug-in.
2. The MyService interface can be as simple as this, with no SwitchYard-specific imports:

   package com.example.switchyard.docs;
   public interface Example {
       public void process(MyData data);
     }
   

3. The generated rule template looks like this:

   package com.example.switchyard.docs
   import org.switchyard.Message
   global Message message
    
   rule "RulesExample"
       when
           // insert conditional here
       then
           // insert consequence here
           System.out.println("service: ExampleService, payload: " + message.getContent());
   end
   

4. Input the values into the SwitchYard Editor's SwitchYard Rules File screen.
5. Click Finish.

1. To map the variables, hover the mouse over the Rules component in switchyard.xml and click Properties icon.
   

   Figure 9.3. Properties dialog for Rules Component

2. In the Properties dialog, click Implementation. From the right hand side panel, click Operations tab to view Operation Mapping tooling window.
   

   Figure 9.4. Operations Mapping

1. Configure the rules implementation.

   Note

   Your expression can use the variables exchange (org.switchyard.Exchange), context (org.switchyard.Context) or message (org.switchyard.Message).

   Context can be accessed in the expression as a java.util.Map. When accessing it as such, the default properties Scope is IN. This can be overridden using the contextScope attribute by changing it to OUT or EXCHANGE
2. Use these global variables in your JBoss Rules Drools Rule Language file:

   package example
    
   global java.lang.String service
   global java.lang.String messageId
   global com.example.Payload payload
    
   rule "Example"
       when
           ...
       then
           ...
           System.out.println("service: " + service + ", messageId: " + messageId + ", payload: " + payload);
   end
   

   Note

   In a more realistic scenario, the payload would be accessed in rule firing because it was inserted into the session directly by the RulesExchangeHandler, and thus evaluated (rather than being accessed as a global).

Procedure 9.11. Add a Property

1. Launch the JBoss Developer Studio's SwitchYard Editor.
2. Open a Type Hierarchy that has a root of org.kie.conf.Option.
3. Here you can see the full list. Here is one example:

   <properties>
       <property name="drools.clockType" value="pseudo"/>
       <property name="drools.eventProcessingMode" value="stream"/>
   </properties>