Using the REST Binding Component

This guide provides an overview of the REST Binding Component, and includes information and instructions for implementing, configuring, and deploying the binding component in a JBI project. The REST Binding Component provides connectivity for Representational State Transfer (REST) over HTTP in a JBI environment.

The REST Binding Component is based on Jersey, which implements the JSR-311 project for JAX-RS (Java API for RESTful Web Services).

What You Need to Know

These topics provide information you should know before you use the REST Binding Component:

• About the REST Binding Component

• REST Binding Component Features

• Supported HTTP Methods

• REST BC Sample Projects

What You Need to Do

These topics provide instructions for using the REST Binding Component:

• Creating the REST BC WSDL Document

• Configuring REST BC WSDL Attributes

• Configuring the REST Binding Component Runtime Properties

• Creating Application Configurations for Connectivity Parameters (URLs)

• Using Application Variables

• Using Predefined Normalized Message Properties

• Implementing Jersey Client Filters

Reference Information

These topics provide additional reference information about configuring and using the REST Binding Component:

• New WSDL Wizard Properties for REST

• Service Level REST WSDL Element

• Binding Level REST WSDL Elements

• REST Binding Component Runtime Property Descriptions

• Normalized Message Properties for REST

About the REST Binding Component

The REST Binding Component provides external connectivity for REST over HTTP, allowing external systems to call RESTful web services hosted by the JBI platform and allowing JBI components to call external web services. Binding components implement the protocol transformations between abstract messages handled by the JBI Service Engines and concrete messages of the protocol. Other JBI components, such as the BPEL Service Engine, can leverage the REST Binding Component to provide and consume RESTful web services.

The REST Binding Component is based on Jersey 1.0.3.1, which implements the JSR-311 project for JAX-RS (Java API for RESTful Web Services). Jersey provides APIs for extending functionality, a client API for REST, an API for JSON support, and an API for using JAXB with JSON. It also supports annotations defined in JSR-311.

Using REST, data and functionality are resources that are accessed through Uniform Resource Identifiers (URIs), which are usually web links. Each discrete resource is identified by a unique URI. The REST Binding Component uses a simple subset of HTTP operations to transfer and transform the data represented by the resources. The data can be of various formats, including plain text, XML, HTML, JSON, and so on.

The REST BC allows you to specify custom HTTP headers and path parameters where needed. Headers define certain traits of the data being processed, including metadata, application state information, and so on. Metadata includes information about the resource, such as the accepted format and content type. The REST BC performs transformation logic based on the HTTP headers. Path parameters can be either query or matrix in style. Query parameters defined attributes of the whole URI, while matrix parameters only modify segments of the URI.

The transformation of abstract messages to REST messages occurs in the REST Binding Component. WSDL extensibility elements are used to configure this transformation. The WSDL extensibility elements are part of the binding and service sections of WSDL documents. Both the binding and service sections of a WSDL document must be properly configured to determine how the message is transformed and the destination of that message.

REST Binding Component Features

The REST BC provides the following features and functionality to GlassFish ESB:

• Gives GlassFish ESB applications the ability to provision and consume RESTful web services.

• Provides easy configuration through a wizard that guides you through the steps of creating a REST WSDL document.

• Allows you to dynamically set HTTP headers and parameters using normalized message properties in a BPEL process.

• Allows you to define application variables and configurations so you can port your REST applications from one environment to another.

• Supports substitution variables in URLs which can be populated from normalized message properties in the BPEL process or from application variables.

• Supports GET, PUT, POST, DELETE, and HEAD HTTP methods.

• Supports XML, JSON, and plain text content types.

• Supports Secure Sockets Layer (SSL).

• Supports Jersey client filters, so you can modify a REST request or response for an outbound REST client interaction.

Supported HTTP Methods

The REST BC supports a subset of HTTP methods to manipulate the requests and responses processed by GlassFish ESB. Certain HTTP methods, such as GET and HEAD, do not make any changes to the resource or to the message and are thus considered to be “safe”. Other method are idempotent, which means that the results of multiple identical request are the same as for a single request. All supported methods except POST fall under this category.

The following subset of HTTP methods are supported for the REST BC:

• GET

  The GET method retrieves specific information from the server as identified by the request URI.

• PUT

  The PUT method requests that the message body sent with the request be stored under the location provided in the HTTP message.

• DELETE

  The DELETE method deletes the specified resources.

• POST

  The POST method modifies data on the server from which a request was sent.

• HEAD

  The HEAD method is similar to the GET method except the message body is not returned in the response. The response only includes metainformation, such as a response code or corresponding headers.

REST BC Sample Projects

There are several sample projects for the REST Binding Component to help you get started with the REST BC and further understand the information and instructions provided in this document. To download the samples and read information on how to run them, go to http://wiki.open-esb.java.net/Wiki.jsp?page=RestBCSamples.

Working With the REST BC WSDL Document

The WSDL document defines a REST interface for the project. You create and configure the WSDL document using the New WSDL Wizard, and you can further configure the interface using the WSDL Editor in NetBeans.

The following topics provides instructions for working with the WSDL document for REST:

• Creating the REST BC WSDL Document

• Configuring REST BC WSDL Attributes

Creating the REST BC WSDL Document

The following topics provide instructions for creating an inbound and outbound REST WSDL document, and also provide reference information for the fields on the New WSDL Wizard.

• To Create a WSDL Document for REST Inbound

• To Create a WSDL Document for REST Outbound

• New WSDL Wizard Properties for REST

To Create a WSDL Document for REST Inbound

1. In the NetBeans Projects window, right-click the project or a folder within the project where you want to add the WSDL document.

2. Point to New and then select WSDL Document.

   The New WSDL Document Wizard appears.

3. Enter a name for the WSDL document, and verify or update the folder location for the file.

4. Select Concrete WSDL Document.

   The Binding and Type fields appear.

5. For the Binding, select REST; for the Type, select REST – Inbound.

   

6. Click Next.

   The Operation Detail window appears with the Get tab displayed.

7. To add a GET operation, do the following:

   1. On the Get tab, click Add Operation.

      New fields appear on the wizard.

      

   2. Enter a name for the operation, and click the Browse buttons to select the request and response message types.

   3. Click Edit Operation.

      The Edit Operation Properties window appears.

      

   4. Enter values for the fields described in Table 1.

8. To add PUT, POST, DELETE, and HEAD operations, repeat the above steps from the appropriate tab on the wizard.

9. On the New WSDL Document Wizard, click Finish.

To Create a WSDL Document for REST Outbound

1. In the NetBeans Projects window, right-click the project or a folder within the project where you want to add the WSDL document.

2. Point to New and then select WSDL Document.

   The New WSDL Document Wizard appears.

3. Enter a name for the WSDL document, and verify or update the folder location for the file.

4. Select Concrete WSDL Document.

   The Binding and Type fields appear.

5. For the Binding, select REST; for the Type, select REST – Outbound.

   

6. Click Next.

   The Operation Detail window appears with the Get tab displayed.

7. To add a GET operation, do the following:

   1. On the Get tab, click Add Operation.

      New fields appear on the wizard.

      

   2. Enter a name for the operation, and click the Browse buttons to select the request and response message types.

   3. Click Edit Operation.

      The Edit Operation Properties window appears.

      

   4. Enter values for the fields described in Table 2.

8. To add PUT, POST, DELETE, and HEAD operations, repeat the above steps from the appropriate tab on the wizard.

9. On the New WSDL Document Wizard, click Finish.

New WSDL Wizard Properties for REST

The following tables list and describe the inbound and outbound operation properties for the REST BC. These properties are accessed from the Operation Details page of the New WSDL Wizard.

Configuring REST BC WSDL Attributes

Once you create the REST BC WSDL document, you can add and update the WSDL attributes that are specific to the REST configuration. The REST BC includes both service-level WSDL elements and binding-level WSDL elements, but some of these elements are placeholders only.

To Configure REST BC WSDL Attributes

1. In the NetBeans IDE, double-click the WSDL document you want to configure.

   The document appears in the WSDL Editor in WSDL view.

2. Click Source.

   The view changes to display the source code.

   ---

   Note –

   Operation properties cannot be configured in WSDL view.

   ---

3. Scroll to the binding element, and modify any of the operation attributes described in REST Operation Element.

4. When you are finished, save and close the file.

Service Level REST WSDL Element

The service-level REST element is rest:address. This is a placeholder element only, and does not need to be configured. When you create a WSDL file in the NetBeans IDE, the New WSDL Wizard generates the empty rest:address element.

The following example illustrates the REST WSDL service element:

<service name="RestOutboundService">
    <port name="RestOutboundWSDL_OutboundPort" binding="tns:RestOutboundBinding">
        <rest:address/>
    </port>
</service>

Binding Level REST WSDL Elements

Binding level WSDL elements allow you to define and configure the REST operation performed against the external resource along with information about the resource. The REST Binding Component binding level WSDL elements include the rest:binding and rest:operation extensibility elements, but the rest:binding element is a placeholder.

REST Binding Element

The REST binding extensibility element specifies that the WSDL document is configured for the REST protocol. This is a placeholder element only, and does not need to be configured. When you create a WSDL file in the NetBeans IDE, the New WSDL Wizard generates a binding element, which includes a name you specify and a type that is generated by the wizard, and also includes the empty rest:bindingelement.

The following example illustrates the REST binding element:

<binding name="RestOutboundBinding" type="tns:RestOutboundPortType">
   <rest:binding/>
   ...

REST Operation Element

The REST operation element includes attributes that define the supported operations, along with payload types, URL information, and HTTP authorization. The REST Binding Component supports the GET, PUT, POST, DELETE, and HEAD operations. These attributes correspond to the properties you can configure from the Edit Operation Properties on the New WSDL Wizard.

When you create a WSDL file in the NetBeans IDE, the New WSDL Wizard generates a rest:operation element in the binding element, and includes any attribute configurations you entered for the operation properties on the wizard.

The following example illustrates the REST operation element:

<binding name="RestOutboundBinding" type="tns:RestOutboundPortType">
   <rest:binding/>
   <operation>
      <rest:operation>
         &lt;![CDATA[
            url=http://{bucket}.s3.amazonaws.com/{resource}
            method=GET
            accept-types=[ "text/plain" ]
            accept-languages=[ ]
            content-type=
            headers={ }
            param-style=Query
            params={ "status" : "Active", "billing" : "Current" }
            basic-auth-username=gsmythe
            basic-auth-password=1qazMKO)
         ]]&gt;
      </rest:operation>
      ...
   </operation>
</binding>

Configuring the REST Binding Component Runtime Properties

The REST Binding Component's runtime properties apply to all instances of the binding component in a domain, including all provider and consumer endpoints. The properties can be configured from the NetBeans IDE, GlassFish Admin Console, or from a command prompt during a command line installation. This section describes how to configure the properties in NetBeans.

To Configure REST BC Runtime Properties

1. From the Services window of the NetBeans IDE, expand the Servers node.

2. If the application server is not already started, right-click the server and then select Start.

3. Under the application server, expand JBI and expand Binding Components.

4. If the REST BC is not started, right-click sun-rest-binding and select Properties.

   The Properties Editor appears.

   

5. Modify any of the properties listed in REST Binding Component Runtime Property Descriptions.

   ---

   Note –

   General, identification, and statistic properties are automatically updated by the REST BC. You do not need to modify these properties.

   ---

6. To apply the changes, stop and restart the REST BC.

REST Binding Component Runtime Property Descriptions

The REST Binding Component properties specify clustering and security settings, and reference descriptive information for the Binding Component. The following tables list and describe each REST Binding Component runtime property.

The Loggers properties specify the level of logging for each event. You can set the logging level for each logger to any of the following levels:

• FINEST: provides highly detailed tracing

• FINER: provides more detailed tracing

• FINE: provides basic tracing

• CONFIG: provides static configuration messages

• INFO: provides informative messages

• WARNING: messages indicate a warning

• SEVERE: messages indicate a severe failure

• OFF: no logging messages

By default, these are all set to the INFO level.

Creating Application Configurations for Connectivity Parameters (URLs)

Application Configurations allow you to configure the external connectivity parameters (URLs) for a JBI application and, without changing or rebuilding the application, deploy the same application into a different system. For example, if you have an application that is running in a test environment, you can deploy it to a production environment using new connectivity parameters without rebuilding the application.

The connectivity parameters for the REST BC are normally defined in the WSDL service extensibility elements. When you create and apply application configurations for these parameters, the values defined for the application configuration override the values defined in the WSDL elements. You apply the configurations to the Composite Application by entering the application configuration name in the Config Extension Name property for the appropriate endpoint.

Perform the following procedures to implement application configurations for the REST BC:

• To Create Application Configurations

• To Add the Application Configuration to the Endpoint

Once you create an application configuration, you can modify it as described in To Change Application Configuration Values.

To Create Application Configurations

You can create several application configurations, which are all referenced by the names you define. Make sure the REST Binding Component is started before you begin this procedure.

1. On the NetBeans IDE Services window, expand Servers > GlassFish v2.1 > JBI > Binding Components.

2. Right-click sun-rest-binding, and then select Properties.

   The Properties window appears.

3. Click the ellipsis next to Application Configuration.

   The Application Configuration Editor appears.

4. Click Add.

   A new row appears in the configuration list.

5. In the new row, enter a name and URL.

   

To Add the Application Configuration to the Endpoint

1. Open the Composite Application Service Assembly in the CASA Editor.

2. Right-click the endpoint to which you want to add the application configuration, and then click Properties.

   The Properties window appears.

3. In the Name property under Config Extension, enter the name of the application configuration.

   

4. Click Close, and then click Save All on the NetBeans toolbar.

5. Once the application configuration values are defined and added to the endpoint, deploy the application.

To Change Application Configuration Values

The REST Binding Component must be started in order to perform this procedure.

1. On the NetBeans IDE Services window, expand Servers > GlassFish v2.1 > JBI > Binding Components.

2. Right-click sun-rest-binding, and then select Properties.

   The Properties window appears.

3. Click the ellipsis next to Application Configuration.

   The Application Configuration Editor appears.

4. Change the value of the URL column for any of the application configurations.

5. To apply the new values, stop and restart any service assemblies that use the application configurations you updated.

Using Application Variables

Application variables allow you to define a list of variable names and values along with their type. The application variable name can then be used as a token for a WSDL extensibility element attribute for the REST BC. For example, you could define a string variable named ServerName with a value of MyHost.com. To reference this in the WSDL document, you would enter ${ServerName}. When you deploy an application that uses application variables, any variable that is referenced in the application's WSDL document is loaded automatically.

If you start an application and a value is not defined for an application variable, an exception is thrown.

You can define the following four variable types:

• String – A string value, such as a path or directory.

• Number – A numeric value.

• Boolean – A Boolean true or false. When you define a Boolean variable, a check box appears in the value field. Select the check box if the variable value should be true; otherwise, deselect the check box.

• Password – A login password. The password is masked and appears as asterisks.

Variables allow greater flexibility in WSDL documents. For example, you can use the same WSDL document for multiple runtime environments by using application variables to specify system-specific information. The variable values can be changed from the binding component runtime properties for each specific environment.

To change a property when the application is running, change your Application Variable property value, then right-click your application in the Services window under Servers -> GlassFish -> JBI -> Service Assemblies, and click Stop in the popup menu. When you restart your project, your new settings will take effect.

To Create an Application Variable

1. On the NetBeans IDE Services window, expand Servers > GlassFish v2.1 > JBI > Binding Components.

2. Right-click sun-rest-binding, and then select Properties.

   The Properties window appears.

3. Click the ellipsis next to Application Variables.

   The Application Variables Editor appears.

4. Click Add.

   A list of possible variable types appears.

5. Select String, Number, Boolean, or Password, and then click OK.

   A new row appears in the application list.

6. In the new row, enter a variable name and then do one of the following:

   • For a Boolean variable, select the check box if the variable value should be true; otherwise leave it deselected.

   • For all other variables types, enter the variable value.

     ---

     Note –

     If you created a password variable, the value you enter appears as asterisks.

     ---

     

   The variable can now be reference from WSDL documents using a dollar sign and curly brackets to indicate the variable; for example, ${MyVariable}.

To Use an Application Variable for Password Protection

To protect passwords that would otherwise appear as clear text in your WSDL document, you can enter a Password application variable as a token. In the following example, a password application variable is created that uses the name SECRET and the password PROTECT.

1. On the NetBeans IDE Services window, expand Servers > GlassFish v2.1 > JBI > Binding Components.

2. Right-click sun-rest-binding, and then select Properties.

   The Properties window appears.

3. Click the ellipsis next to Application Variables.

   The Application Variables Editor appears.

4. Click Add, select Password, and then click OK.

   A new row appears in the variable list.

5. Enter SECRET as the name, and enter PROTECT as the value.

   Because this is a password type, the characters appear as asterisks.

6. Use the application variable name ${SECRET} as the WSDL password attribute, using the dollar sign and curly braces as shown.

Using REST BC Normalized Message Properties in a Business Process

You can define normalized message properties in a BPEL process in order to dynamically assign values to the runtime properties for the REST BC. The normalized message properties for each JBI component are accessed from the BPEL Designer Mapper view. When you expand a variable's Properties folder it exposes the variable's predefined NM properties, as well as the standard BPEL-specific WSDL properties used in correlation sets, assigns, and expressions . If the specific NM property you need is not currently listed, additional NM properties can be added.

Normalized message properties provide the following capabilities:

• Getting and setting transport context properties, such as REST headers.

• Getting and setting request parameters.

• Dynamically configuring REST properties.

Using Predefined Normalized Message Properties

Predefined normalized message properties are automatically available from the BPEL Designer's Mapper view. You can use additional properties by adding them directly to the source code. You can either define these properties using the BPEL Designer Mapper, or by entering the code directly into the source view.

You can perform additional tasks when working with normalized message properties, such as creating additional properties, deleting properties, creating property shortcuts, and so on. For more information, see Using Normalized Message Properties in BPEL Designer and Service Engine User’s Guide.

To Use Predefined Normalized Message Properties in Mapper View

You can access most of the normalized message properties from the BPEL Mapper. Certain properties, such as path and query parameters, need to be defined in the Source view.

1. Open the BPEL process you want to edit in the BPEL Designer.

2. In Design view, select the activity to add the normalized message property to.

3. In the BPEL Designer toolbar, click Mapper.

4. In the Output pane, expand the variable you want to edit, expand Properties, and then expand REST BC.

5. Expand Request Metadata or Response Metadata, depending on the message type.

   A list of available normalized message properties appears.

   

6. Select the normalized message property you want to use, and use the mapper operands to build an expression or assign a value.

   For a complete list of normalized message properties for the REST BC, see Normalized Message Properties for REST.

To Use Predefined Normalized Message Properties in Source View

You can define any of the normalized message properties using the Source view. You can only access path or query parameters from the Source view.

1. Open the BPEL process you want to edit in the BPEL Designer.

2. In the BPEL Designer toolbar, click Source.

   The BPEL source code for the process is now visible.

3. Declare the sxnmp namespace near the beginning of the process element; for example:

   xmlns:sxnmp="http://www.sun.com/wsbpel/2.0/process/executable/SUNExtension/NMProperty"

4. Access the property using the property names listed and described in Normalized Message Properties for REST.

   For path and query parameters, separate normalized message properties are created for each. For example,

   <assign name="AssignActivity"> <copy> <from variable="GetCustomerNameIn" sxnmp:nmProperty="org.glassfish.openesb.rest.path-params.custName"/> <to>$CustomerQuery_OperationIn.part/ns0:param1</to> </copy> </assign>

Example 1 Using REST BC Normalized Message Properties for Query Parameters

There are two methods to use normalized message properties to encode information as query parameters in an outbound REST call. Both methods are illustrated below in examples that show how to define query parameters for a simple address.

The following example illustrates defining all the parts and assigning their values as a single string.

<copy>
    <from>'{"street":"800 Royal Oaks Blvd.", "city":"Monrovia", "state":"CA", "zip":"91016"}'</from>
    <to variable="YahoomapIn" sxnmp:nmProperty="org.glassfish.openesb.rest.params"/>
</copy>

The following example illustrates defining each part as a query parameter and assigning the values individually.

<copy>
    <from>'800 Royal Oaks Blvd.'</from>
    <to variable="YahoomapIn" 
        sxnmp:nmProperty="org.glassfish.openesb.rest.params.street"/>
</copy>
<copy>
    <from>'Monrovia'</from>
    <to variable="YahoomapIn" 
        sxnmp:nmProperty="org.glassfish.openesb.rest.params.city"/>
</copy>
<copy>
    <from>'CA'</from>
    <to variable="YahoomapIn" 
        sxnmp:nmProperty="org.glassfish.openesb.rest.params.state"/>
</copy>
<copy>
    <from>'91016'</from>
    <to variable="YahoomapIn" 
        sxnmp:nmProperty="org.glassfish.openesb.rest.params.zip"/>
</copy>

Normalized Message Properties for REST

Normalized message properties are either specific to the binding component being used or generally available to all participating JBI components. The following topics describe both types of normalized message properties.

• General Normalized Message Properties

• REST Binding Component Normalized Message Properties

General Normalized Message Properties

The following table lists and described the general properties that are available to all JBI components. All property values are of the type java.lang.String.

REST Binding Component Normalized Message Properties

The following properties are specific to the REST Binding Component. Available properties are different for request messages than for response messages. All property values are of the type java.lang.String.

Implementing Jersey Client Filters

You can use Jersey client filters to modify a REST request or response for an outbound REST client interaction. For example, you can define a filter for generating the appropriate authentication header based on user-supplied information. To implement filters, you need to define the logic

To Define the Jersey Filter

You define the client filter in a Java Application project in NetBeans using the Jersey client API to define the logic. For more information about the Jersey API, see the Jersey 1.0.3.1 Javadocs. The following are the primary classes of interest:

• com.sun.jersey.api.client.ClientHandlerException

• com.sun.jersey.api.client.ClientRequest

• com.sun.jersey.api.client.ClientResponse

• com.sun.jersey.api.client.filter.ClientFilter

1. Right-click in the Projects window of the NetBeans IDE, and then select New Project.

   The New Project Wizard appears.

2. Select Java in the Categories list, and then select Java Application in the Projects list.

3. Click Next.

   The Name and Location window appears.

4. Enter a name for the project and a name for the main Java class, and then click Finish.

   The project is created and a Java file containing the code framework appears in the Java Editor.

   

5. If you did not specify the class name in the wizard, you can do the following to rename the Java class:

   1. In the Projects window under the Java project, right-click Main.java.

   2. Point to Refactor and then select Rename.

   3. Enter the new name, and then click Refactor.

6. Do the following to add the required Jersey JAR files to the project:

   1. In the Project window, right-click the Java application, and then select Properties.

      The Properties window appears.

   2. Under Categories, select Libraries.

   3. Click the Compile tab, and then click Add Jar/Folder.

   4. Browse to and select the following Jersey JAR files:

      • jersey-bundle-1.0.3.1.jar

      • jsr311-api-1.0.jar

        ---

        Tip –

        You can find these files in glassfish-home/lib.

        ---

      

   5. Click OK.

7. Define the processing logic for the filter in the Java package that was created for you by the wizard.

   Use standard Java methods along with the methods defined in the Jersey API to define the filter, exception, and logging logic. See the example following this procedure for a simple implementation.

Example 2 Simple Authentication Filter

The following example illustrates the code for a simple authentication filter that has a user name and password as parameters.

package javafilter;

import com.sun.jersey.api.client.ClientHandlerException;
import com.sun.jersey.api.client.ClientRequest;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.filter.ClientFilter;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Filter extends ClientFilter {

   private static final Logger logger = Logger.getLogger(Filter.class.getName());
   private String username;
   private String password;

   public Filter() {
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   @Override
   public ClientResponse handle(ClientRequest request) throws ClientHandlerException {

       logger.log(Level.INFO, "inside handle() method, username=" + username + 
                  ", password=" + password);

       ClientResponse response = getNext().handle(request);
       return response;
   }
}

To Add the Filter to the Composite Application

Before You Begin

Before you can perform this step, you need to complete the following steps:

• Create the BPEL Module that implements the REST Binding Component.

• Create and build the composite application for the BPEL Module.

• Create he Java Application that defines the filter (as described in To Define the Jersey Filter), and build the Java Application project.

1. Open the composite application for the project in which you want to implement filters.

2. On the CASA Editor, right-click the REST outbound endpoint to which you want to add the filter, and then click Properties.

   

   The Properties Editor appears.

   

3. Click the ellipsis next to the Filters property under JAX-RS (Jersey) Extension.

   The Filters Editor appears.

4. On the Filters Editor, click Add.

5. From the dialog box that appears, navigate to and select the Java Application project you created to define the filter logic. Click Open.

   The Select Java Libraries dialog box appears.

6. Click OK on the dialog box. Do not select the Jersey libraries.

   The information from the Java Application project is populated into the Filter Editor.

   

7. If you defined parameters for the filter, enter the parameter values in the Parameters section at the bottom of the editor.

8. Click OK.

   The filter name appears in the Filters property.

9. Click Close on the Properties Editor.