Skip to main content

By clicking Submit, you agree to the developerWorks terms of use.

The first time you sign into developerWorks, a profile is created for you. Select information in your developerWorks profile is displayed to the public, but you may edit the information at any time. Your first name, last name (unless you choose to hide them), and display name will accompany the content that you post.

All information submitted is secure.

  • Close [x]

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerworks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

By clicking Submit, you agree to the developerWorks terms of use.

All information submitted is secure.

  • Close [x]

Integrate social networks into BPM, Part 1: Collect Twitter data

Use Bonita's process engine and connector framework to integrate external applications

Bilal Siddiqui , Freelance consultant
Bilal Siddiqui is an electronics engineer, XML consultant, technology evangelist, and frequently published technical author. He is the founder of XML4Java.com, a company focused on simplifying e-business. After graduating in 1995 from the University of Engineering and Technology, Lahore, Bilal began designing software solutions for industrial control systems. Later, he turned to XML and built web- and WAP-based XML processing tools, server-side parsing solutions, and service applications. Since 2006, he has focused exclusively on Java- and XML-based open source tools and solutions. A strong advocate of open source tools, he not only designs solutions based on them but also trains software and IT personnel at Lahore universities in using open source technologies. Bilal is the author of JasperReports 3.6 Development Cookbook (Packt Publishing, 2010).

Summary:  Thanks to the flexibility of business process management (BPM) tools, you can integrate social networks into a company's business processes with minimal coding. This two-part article shows how an application built with Bonita Open Solution — an open source BPM tool — collects, displays, and uses data from social-networking sites. Part 1 shows how to configure the application to connect to the Twitter web service and enable users to do a keyword search for relevant data. In Part 2, you'll see how the application interfaces with a customer relationship management (CRM) system.

IBM and BPM

IBM has long been active in the area of business process, offering a robust set of commercial tooling to model, simulate, execute, adapt, monitor, and optimize your business processes. In April, IBM announced Business Process Manager V7.5, a substantial update to its comprehensive BPM platform. Expected availability is June 2011. In the meantime, keep up with IBM's BPM activities on developerWorks.

Compelled by the increasing business value of social-networking websites such as Twitter and Facebook, enterprises want quick and easy ways to integrate social networks into their business processes. One efficient approach is to use BPM tools, which are highly capable of integrating external applications and data into business workflows.

This two-part article shows how to use Bonita, an open source BPM tool, to build a social-media search application for a hypothetical company. The application consists of a business process that integrates seamlessly with external applications. It lets users do a keyword search to collect business-related data from a social-networking site and then add some of that data to a CRM system with a single button click. Part 1 describes the application's user interface and architecture, then walks through the steps for configuring Bonita to fetch and display Twitter data in a business process. Part 2 completes the application by integrating it with the company's CRM system.

Exercise: IBM BPM in action

IBM BPM provides the end-to-end process visibility and control that is critical for organizations to survive and excel in today's constantly changing business environment. Use the IBM BPM in action exercise to model and run business processes in a visual, code-free environment.

The source code for this article's application is available for download. To follow the article's steps hands-on, download and install Bonita and Twitter4J before proceeding (see Resources for download links). I used Bonita version 5.4 and Twitter4J version 2.1.12 to develop the application.

Application overview

The entire application is developed as a business process through Bonita process configuration. A simple UI lets users search for data of business value from Twitter and displays messages (tweets) that meet the search criteria. The user selects a tweet of interest from the results and fetches the profile of the Twitter user who posted it. The search application also enables the application user to add that Twitter user as a potential contact in SugarCRM, an open source CRM system.

User interface

The search application's UI consists of three simple forms that I've implemented using Bonita's form designer. The first form presents two UI components: a Search Keyword text box and a Search button, as shown in Figure 1:


Figure 1. The Search Tweets form
Screenshot of the Search Tweets form in Bonita

Bonita's form designer is quite powerful, providing graphical components for form design and allowing you to link user actions with other forms or back-end activities through configuration screens. For example, Bonita allows you to configure the Search button in Figure 1 to be linked to the back-end search activity that looks for relevant tweets.

After the user enters a search keyword and clicks the Search button, control is transferred to Bonita's business process engine. The engine works in the background to fetch tweets containing the search keyword. Bonita displays the messages it finds on a second UI form, as shown in Figure 2:


Figure 2. Form showing Twitter messages
Screenshot of Bonita UI form showing twitter messages

The user can select any message and click the View Profile button. Control is again transferred to Bonita's process engine, which works in the background to fetch profile data for the Twitter user who sent that tweet. The Twitter user's profile is displayed in a third UI form, as shown in Figure 3:


Figure 3. User Profile form
Screenshot of Bonita form showing profile of the Twitter user

Users can click the Add to CRM button on the third UI form to add the Twitter user to their business contacts in SugarCRM. Bonita's process engine interfaces seamlessly with SugarCRM to make this possible.

Application architecture

BPM tools like Bonita have the flexibility to integrate with a variety of applications. Bonita's flexibility comes from its process engine and its connector framework. I'll describe the application's architecture to show how the process engine and connector framework work with other components. Figure 4 diagrams the architecture:


Figure 4. Architecture of the search application
Figure 4. Diagram of the search application's architecture

You can see in Figure 4 that the search application consists of several major components:

  • User interface
  • Process variables
  • Bonita's process engine
  • Bonita's connector framework
  • Twitter4J
  • SugarCRM API

I've already covered the UI, so I'll discuss the other boxes shown in Figure 4:

  • Process variables: Bonita provides process variables to hold application data. Both application-level and local temporary variables are available. Bonita provides a GUI for configuring variables according to your application's business logic and evaluating mathematical and logical expressions based on process variables.
  • Bonita's process engine: Bonita's process engine coordinates all the activities occurring among different application components. At the start, the process engine identifies the UI form to be displayed to the application user. After the user enters search keywords, the process engine handles the application's flow and allows process variables to capture user input. You can say that the process engine manages the process's life cycle according to the business logic throughout the execution of the application.
  • Bonita's connector framework: The connector framework is Bonita's extensibility mechanism for integrating with outside applications. You use the framework to build custom connectors. You can see that the connector framework box in Figure 4 contains three connectors — TwitterSearchConnector, TwitterUserProfileConnector, and SugarCRMAddContactConnector — all built using the connector framework. Each connector does a particular task. For example, TwitterSearchConnector acts as a search engine to search for messages of interest on Twitter.
  • Twitter4J: The Twitter4J box is connected through the Internet to the Twitter web service, which lets client applications (such as the search application) interact with the Twitter web site. Twitter4J is an open source Java API that makes it easy to work with the Twitter web service (see Resources). The TwitterSearchConnector wraps Twitter4J inside Bonita's connector framework to enable Bonita to start working with the Twitter web service. (You will learn how to do this in this article's Implementing the TwitterSearchConnector class section.)
  • SugarCRM API: I'll discuss this component in Part 2.

Next I'll describe how the components of the search application work together.

Component-interaction sequence

Figure 5 shows the sequence of events that happens when a business user uses the search application to interact with the Twitter web service:


Figure 5. Sequence of events in the search application
Diagram showing the sequence of events in the search application
  1. The user enters a search keyword in the first UI form (Figure 1) and clicks the Search button.
  2. Bonita's process engine receives the search keyword and stores it in a process variable.
  3. Bonita's process engine invokes TwitterSearchConnector.
  4. TwitterSearchConnector uses Twitter4J to authenticate itself with the Twitter web service and send it a search query containing the search keyword.
  5. The Twitter web service receives the search query, performs the actual search operation over Twitter, and returns the relevant messages to TwitterSearchConnector.
  6. TwitterSearchConnector receives the search results and hands them over to Bonita's process engine.
  7. Bonita's process engine populates a process variable with the search results. Then it identifies the next task in the sequence and hands over control to the search-results form (Figure 2).
  8. The search-results UI form fetches the response from the process variable and displays the messages to the user.

The search sequence can continue in a similar way from the second UI form (Figure 2) to the user-profile form (Figure 3). If a user selects one of the tweets displayed in the second form and clicks the View Profile button, the process engine calls TwitterUserProfileConnector, which fetches the profile of the user who posted that tweet. Similarly, if the user decides to add that Twitter user's contact information into SugarCRM (by clicking the Add to CRM button), the process engine calls the SugarCRM connector, which in turn adds the contact information to the CRM system.

You can see from this sequence of events that Bonita's process engine has a central role in coordinating all activities of the search application. Therefore, developing the search application in Bonita consists of telling Bonita's process engine what it must do at every step. This is called configuring a business process in Bonita. The rest of this article describes how to start configuring the search application.


Configuring the search application

The application-configuration tasks that you'll complete are:

  1. Create a Twitter account.
  2. Register the application with the Twitter web service and get security credentials for authentication.
  3. Design and configure TwitterSearchConnector.
  4. Configure the application's remaining components in Bonita (finishing in Part 2).

The first step, creating a Twitter account, is even simpler than creating an email account. The search application will act as a client of the Twitter web service. For the purpose of this article, I created a Twitter account named searchMessages. If you want to perform the configuration steps yourself, go to https://twitter.com/signup and create your own account now.

Registering the application with Twitter and getting security credentials

By registering an application with the Twitter web service, you get two pairs of keys:

  • A consumer key and a consumer secret that represent the client application: The search application will use this pair of keys to access the Twitter web service using the account you've created.
  • An access token and an access-token secret: The access token in conjunction with the secret will be used to sign the requests the search application sends to the Twitter web service.

The security mechanism behind the two pairs of keys is called the Open Authentication (OAuth) protocol (see Resources). You don't need to worry about how OAuth works, because Twitter4J handles it behind the scenes. The TwitterSearchConnector uses Twitter4J classes.

Log in to the Twitter web site (http://www.twitter.com) using the account you created earlier. Type https://dev.twitter.com/apps/new in your browser's address bar. You will see the Register an Application page, as shown in Figure 6:


Figure 6. Register an Application page on Twitter
Figure 6. Screenshot of the Register an Application page on Twitter

Fill in the page as follows:

  1. Enter Bonita search client in the text box labeled Application Name.
  2. Type a short description (such as Client that searches for data on Twitter in the Description field.
  3. Enter the URL for your application in the Application Website field.
  4. Select the Client radio button for Application Type. This means that your search application will act as a web service client.
  5. Select the Read-only radio button for Default Access Type (because the application just needs to search for Twitter data, not send out any Twitter messages).

Leave the Organization and Callback URL fields empty and submit the completed form. You will get the Bonita search client Settings page giving you your security credentials, as shown in Figure 7:


Figure 7. The Bonita search client Settings page on Twitter
Figure 7. Screenshot of the Bonita search client Settings page of Twitter

Write down the consumer key and consumer secret, because you will need them later.

To get the second key pair (access token and access token secret), click the My Access Token button that's circled in red in Figure 7. The access token and its secret are then displayed on another Twitter page, named Bonita search client Access Token Requisition, as shown in Figure 8:


Figure 8. The Bonita search client Access Token Requisition page on Twitter
Figure 8. Screenshot of the Bonita search client Access Token Requisition page of Twitter

Write down the access token and access token secret.

Now that you have the two key pairs, the next step is to design and configure TwitterSearchConnector.

Designing and configuring TwitterSearchConnector

Implementing a connector in Bonita is mostly a configuration task, which involves a few steps:

  1. Provide descriptive information.
  2. Configure input and output parameters for the connector.
  3. Generate a Java code template for your connector. Bonita uses the Eclipse Modeling Framework (EMF) and Graphical Modeling Framework (GMF) (see Resources) to generate a connector template. The template contains all the Java code that Bonita's connector framework requires, letting you focus on your connector's business logic. The only time you'll need to write Java code for the application is when you use Twitter4J.

Bonita provides graphical wizards for almost every configuration step.

Run Bonita. Figure 9 shows the welcome page:


Figure 9. Bonita welcome page
Figure 9. The welcome page of Bonita

Select Connector > New connector from the welcome page's menu. (I've circled in the Connector menu item in red in Figure 9.) A new Connector creation wizard appears, as shown in Figure 10:


Figure 10. Connector creation wizard
Figure 10. Screenshot of Bonita's Connector creation wizard

You can see from Figure 10 that the Connector creation wizard is divided into upper and lower portions. The upper portion collects descriptive information for the connector (Connector Id, Description, Category, and Name of the Java class that will represent the connector). The lower portion consists of two table-like graphical widgets (Pages and Outputs), which allow you to define input and output parameters.

Enter TwitterSearchConnector in the Connector Id text field and Search tweets in the Description text field. Then select Social from the Category list. The category field helps Bonita to categorize your connectors. You can see that Bonita automatically uses the Connector Id field to fill the Class Name field, which is the name of the Java class for this connector.

Click the Browse button next to the Package field to select the package of your choice for your TwitterSearchConnector class. You can also specify an icon for your connector, which I am not doing in this article. This finishes the description information.

After you have provided the description information, the wizard of Figure 10 looks like Figure 11:


Figure 11. Connector creation wizard showing descriptive information about TwitterSearchConnector
Figure11. Screenshot of Bonita's Connector creation wizard showing descriptive information about TwitterSearchConnector

Now you will define input parameters for TwitterSearchConnector.

Configuring input parameters for TwitterSearchConnector

Use the Pages table in the lower portion of Connector creation wizard to configure input parameters for TwitterSearchConnector. Note that input parameters are to be passed by Bonita to TwitterSearchConnector. The Connector creation wizard allows you to group input parameters as pages. This means that while configuring a business process, you can pass a number of input parameters from one page. This page will be displayed to you when you add this connector to the search business process in Part 2.

Your TwitterSearchConnector needs the two pairs of keys (consumer key, consumer secret, access token, and access token secret) and the search keyword that's entered in the first UI form (Figure 1). So you must define five input parameters for your TwitterSearchConnector: the four security credentials, which are fixed when you add TwitterSearchConnector to the search business process; and the search keyword, which is dynamic — that is, the user supplies it every time he or she performs a search.

Click the Create button (circled in red in Figure 11) that's to the right of the Pages table. This opens a new page containing fields for configuring input parameters for TwitterSearchConnector, as shown in Figure 12:


Figure 12. Page for configuring input parameters
Figure 12. Screenshot of the Bonita page for configuring input parameters

You can see from Figure 12 that the input-parameter page contains three fields: Page Id, Page Title, and Description. For your input-parameter page, simply enter TwitterSearchConnectorInputParametersPage in the Page Id field and then type Twitter Search Connector Input Parameters Page in the Page Title and Description fields.

Below the three fields, you find a Widgets table, which asks you to provide four fields for each of your input parameters. Field name is the name of the parameter, Mandatory specifies whether the parameter is mandatory or optional, Widget specifies which visual component is associated with this input parameter, and the Data type field specifies the data type of the variable associated with this parameter.

Now you will configure the four fields for each of the five input parameters. Click the Create button, circled in red in Figure 12. A row in the Widgets table will appear in which you can enter consumerKey as the field name, Mandatory in the Mandatory column, Password in the Widget column, and Text as value of the Data type column. Use these same values for all five input parameters, as shown in Figure 13:


Figure 13. The completed page for configuring input parameters
Figure 13. Screenshot of the completed input-parameter configuration page in Bonita, including the data you have entered

Click the OK button at the bottom of the page. Bonita will save the input parameters configurations and will take you back to the earlier Connector creation wizard of Figure 10.

Configuring output parameters

You need to define only one output parameter, named searchResults, for your TwitterSearchConnector. Click the Create button (circled in blue in Figure 11) that's next to the output table . A new row appears in the output table. You can see you must provide data in just two columns for the output parameters. Enter searchResults in the Field name column. In the Data type column, select List from the drop-down. The Connector creation wizard, which now contains all the configuration data that you have provided for input and output parameters, should look like Figure 14:


Figure 14. Connector creation wizard containing configuration data for input and output parameters
Figure 14. Connector creation wizard containing configuration data for input and output parameters

Click the Finish button on the Connector creation wizard. Bonita immediately generates all the code for input and output parameters of the TwitterSearchConnector class and displays the code in an editor, as shown in Figure 15:


Figure 15. Template code of the TwitterSearchConnector class
Figure 15. Screenshot showing the template code of the TwitterSearchConnector class

Bonita saves the automatically generated code for the TwitterSearchConnector class in the X:\BOS-5.4\studio\workspace\local_default_My Extensions\src-connectors\org\bonitasoft\connectors\twitter folder of your Bonita installation. (This article's source-code download includes TwitterSearchConnector.java for your convenience.) Next, you'll learn what you need to do with this code.

Implementing the TwitterSearchConnector class

Listing 1 shows the TwitterSearchConnector class:


Listing 1. The TwitterSearchConnector class generated by Bonita

public class TwitterSearchConnector extends ProcessConnector {

    private String consumerKey;
    private String accessToken;
    private String accessTokenSecret;
    private String consumerSecret;
    private String searchKeyword;

    @Override
    protected void executeConnector() throws Exception {
        // TODO Auto-generated method stub
    }

    @Override
    protected List<ConnectorError> validateValues() {
        // TODO Auto-generated method stub
        return null;
    }

    public void setConsumerKey(String consumerKey) {
        this.consumerKey = consumerKey;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public void setSearchKeyword(String searchKeyword) {
        this.searchKeyword = searchKeyword;
    }

    public void setAccessTokenSecret(String accessTokenSecret) {
        this.accessTokenSecret = accessTokenSecret;
    }


    public void setConsumerSecret(String consumerSecret) {
        this.consumerSecret = consumerSecret;
    }

    public List getSearchResults() {
        // TODO Add return value for the output here
        return null;
    }
}

As you can see in Listing 1, TwitterSearchConnector extends the ProcessConnector class, which is part of the connector framework. ProcessConnector provides functionality to manage multiple instances of a connector running in separate threads of execution within Bonita's process engine.

The ProcessConnector class in turn extends Connector, which is the base class of the connector framework. It provides functionality to handle common tasks such as input validation and exception handling.

If you look at the class-level variables in Listing 1, you'll notice that Bonita has declared five variables corresponding to the five input parameters that you configured in the Configuring input parameters of TwitterSearchConnector section.

You also configured an output variable in the Configuring output parameters section, but Bonita has not declared an output variable in the TwitterSearchConnector class. So, you must manually add a sixth variable, named searchResults, to store connector output, as shown in bold in Listing 2:


Listing 2. Class-level variables for the TwitterSearchConnector class

//Class level variables
    private String consumerKey;
    private String accessToken;
    private String accessTokenSecret;
    private String consumerSecret;
    private String searchKeyword;

//Manually added output variable
private List<Tweet> searchResults;

Now look at setter and getter methods in Listing 1. You can see a setter method for each of the five input parameters (setConsumerKey(), setConsumerToken(), setAccessToken(), setAccessTokenSecret(), and setSearchString()). Notice also that the class has only one getter method, named getSearchResults(). It corresponds to the searchResults output variable. However, the getSearchResults() method returns null in Listing 1, so you must edit it manually, as shown in Listing 3, to return the searchResults output variable instead of null:


Listing 3. Manually edited getSearchResults() method

//Manually edited form of the getSearchResults()
public List<Tweet> getSearchResults() {
   return searchResults;
}

Now look at the executeConnector() method in Listing 1. You need to fill this empty method with the business logic of TwitterSearchConnector. The next section describes how to implement the logic using Twitter4J.

Implementing the executeConnector() method

The executeConnector() method of Bonita's connector framework allows you to implement your connector's business logic. Bonita's process engine will call the executeConnector() method each time TwitterSearchConnector is invoked. Listing 4 shows the executeConnector() method:


Listing 4. The executeConnector() method

protected void executeConnector() throws Exception {
   //Step1:
   Twitter twitter = new TwitterFactory().getInstance();

   //Step2:
   twitter.setOAuthConsumer(consumerKey, consumerSecret);
   twitter.setOAuthAccessToken(new AccessToken(accessToken, accessTokenSecret));
   
   //Step3:
   twitter4j.Query query = new twitter4j.Query(searchKeyword);
   twitter4j.QueryResult queryResult = null;
   
   //Step4:
   try
   {
      queryResult = twitter.search(query);
      searchResults = queryResult.getTweets();
   }
   catch (TwitterException e) {
      System.out.println ("Twitter follow a user exception");
      e.printStackTrace();
   }
}

The executeConnector() method uses Twitter4J to implement your business logic. The executeConnector() method is simple, consisting of four steps:

  1. Create an instance of the Twitter class with the help of a factory class named TwitterFactory. The Twitter class allows you to use many useful methods of Twitter4J.
  2. Call the setOAuthConsumer() and setOAuthAccessToken() methods of the Twitter class, passing authentication data (consumerKey, consumerSecret, accessToken, and accessTokenSecret) along with the method call. Twitter4J handles authentication internally.
  3. Instantiate the Query and QueryResult objects. The Query object wraps the search keyword, and the QueryResult object wraps the search results.
  4. Call the Twitter class's search() method, which takes the Query object as a parameter and returns search results wrapped inside the QueryResult object. Then extract messages from the QueryResult object by calling its getTweets() method, and store the messages in the searchResults variable.

Trying the TwitterSearchConnector class stand-alone

I've included a main() method in the TwitterSearchConnector class so you can test the class's functionality in stand-alone mode without needing to run Bonita. Listing 5 shows the main() method:


Listing 5. The main() method of the TwitterSearchConnector class


public static void main(String args[]) {
   //Step1: Instantiate
   TwitterSearchConnector twitterSearchConnector = 
      new TwitterSearchConnector();

   //Step2: Provide security information
   twitterSearchConnector.setConsumerKey(args[0]);
   twitterSearchConnector.setConsumerSecret(args[1]);
   twitterSearchConnector.setAccessToken(args[2]);
   twitterSearchConnector.setAccessTokenSecret(args[3]);
   twitterSearchConnector.setSearchKeyword(args[4]);

   //Step3: Search Twitter
   try 
   {
       twitterSearchConnector.executeConnector();
   }catch (java.lang.Exception e){
      e.printStackTrace();
   }
   List <Tweet> tweets = twitterSearchConnector.getSearchResults();

   //Step4: Print Twitter messages
   for (int i=0; i<tweets.size(); i++)
   {
      System.out.println ("User Name: ["+tweets.get(i).getFromUser()+"]");
      System.out.println ("Message ["+tweets.get(i).getText() +"/r/n");
   }
}//main

The main() method:

  1. Instantiates the TwitterSearchConnector class.
  2. Provides all the security and search-keyword data to the TwitterSearchConnector class.
  3. Calls the executeConnector() method.
  4. Prints the search results on the output console.

You can use the SearchTweetsCompile.bat and SearchTweetsRun.bat files provided in this article's source code download to compile and run the TwitterSearchConnector class as a stand-alone application. The two pairs of keys are hard-coded in the SearchTweetsRun.bat file.

The TwitterSearchConnector class uses Bonita libraries as well as Twitter4J, so Bonita-client-5.4.jar from the Bonita's download and twitter-core-2.1.12.jar from Twitter4J need to be in your classpath.

Figure 16 shows my output console after I run the SearchTweetsRun.bat file:


Figure 16. Contents of the output console in stand-alone mode
Figure 16. Screenshot showing contents of the output console when the TwitterSearchConnector class is run in standalone mode

The console displays the user name and message content for each tweet located by a search for the keyword CRM.


Part 1 wrap-up

I have discussed the architecture of the search application, showing how Bonita's process engine and its connector framework can cooperate with each other to integrate social-networking data into a business process. You have seen how to configure TwitterSearchConnector and also test the TwitterSearchConnector class in stand-alone mode. In Part 2, I'll show you how to complete the application by configuring the remaining connectors to capture Twitter user profiles and integrate them into SugarCRM. The application will then comprehensively demonstrate how to integrate a business process running inside Bonita with a variety of external applications.



Download

DescriptionNameSizeDownload method
Source code for this article's examplej-sb1.zip7KBHTTP

Information about download methods


Resources

Learn

Get products and technologies

Discuss

About the author

Bilal Siddiqui is an electronics engineer, XML consultant, technology evangelist, and frequently published technical author. He is the founder of XML4Java.com, a company focused on simplifying e-business. After graduating in 1995 from the University of Engineering and Technology, Lahore, Bilal began designing software solutions for industrial control systems. Later, he turned to XML and built web- and WAP-based XML processing tools, server-side parsing solutions, and service applications. Since 2006, he has focused exclusively on Java- and XML-based open source tools and solutions. A strong advocate of open source tools, he not only designs solutions based on them but also trains software and IT personnel at Lahore universities in using open source technologies. Bilal is the author of JasperReports 3.6 Development Cookbook (Packt Publishing, 2010).

Report abuse help

Report abuse

Thank you. This entry has been flagged for moderator attention.


Report abuse help

Report abuse

Report abuse submission failed. Please try again later.


developerWorks: Sign in


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Select information in your developerWorks profile is displayed to the public, but you may edit the information at any time. Your first name, last name (unless you choose to hide them), and display name will accompany the content that you post.

Choose your display name

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


Rate this article

Comments

Help: Update or add to My dW interests

What's this?

This little timesaver lets you update your My developerWorks profile with just one click! The general subject of this content (AIX and UNIX, Information Management, Lotus, Rational, Tivoli, WebSphere, Java, Linux, Open source, SOA and Web services, Web development, or XML) will be added to the interests section of your profile, if it's not there already. You only need to be logged in to My developerWorks.

And what's the point of adding your interests to your profile? That's how you find other users with the same interests as yours, and see what they're reading and contributing to the community. Your interests also help us recommend relevant developerWorks content to you.

View your My developerWorks profile

Return from help

Help: Remove from My dW interests

What's this?

Removing this interest does not alter your profile, but rather removes this piece of content from a list of all content for which you've indicated interest. In a future enhancement to My developerWorks, you'll be able to see a record of that content.

View your My developerWorks profile

Return from help

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Java technology
ArticleID=657557
ArticleTitle=Integrate social networks into BPM, Part 1: Collect Twitter data
publish-date=05162011
author1-email=xml4java@yahoo.co.uk
author1-email-cc=jaloi@us.ibm.com

Tags

Help
Use the search field to find all types of content in My developerWorks with that tag.

Use the slider bar to see more or fewer tags.

For articles in technology zones (such as Java technology, Linux, Open source, XML), Popular tags shows the top tags for all technology zones. For articles in product zones (such as Info Mgmt, Rational, WebSphere), Popular tags shows the top tags for just that product zone.

For articles in technology zones (such as Java technology, Linux, Open source, XML), My tags shows your tags for all technology zones. For articles in product zones (such as Info Mgmt, Rational, WebSphere), My tags shows your tags for just that product zone.

Use the search field to find all types of content in My developerWorks with that tag. Popular tags shows the top tags for this particular content zone (for example, Java technology, Linux, WebSphere). My tags shows your tags for this particular content zone (for example, Java technology, Linux, WebSphere).

Try IBM PureSystems. No charge.

Special offers