Chapter 7. Using the jUDDI Client

Procedure 7.1. Task

1. Open META-INF/uddi.xml in your text editor.
2. Configure the settings.
3. Save and exit.
4. Include the uddi.xml file in your archive when you deploy it.
5. Call this code:

   UDDIClerkManager clerkManager = new UDDIClerkManager("META/myuddi.xml");
   clerkManager.start();
   

6. Alternatively, if your application deploys as a WAR archive, add your client configuration to yourwar/META-INF/myuddi.xml and, in the web.xml file, specify these context parameters: uddi.client.manager.name and uddi.client.xml.
   In this example, both context parameters are set and on deployment the UDDIClerkServlet takes care of reading the configuration:

          <!-- required -->
   <context-param>
       <param-name>uddi.client.manager.name</param-name>
       <param-value>example-manager</param-value>
    </context-param>
    
   <!-- optional override -->
   <context-param>
       <param-name>uddi.client.xml</param-name>
       <param-value>META-INF/myuddi.xml</param-value>
   </context-param>
   
   <servlet>
       <servlet-name>UDDIClerkServlet</servlet-name>
       <display-name>Clerk Servlet</display-name>
       <servlet-class>org.apache.juddi.v3.client.config.UDDIClerkServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
   </servlet>
   

Procedure 7.2. Task

• Ensure that the JAX-WS URLs are pointing to an address where the UDDI client can find the WSDL documents:

  <!-- JAX-WS Transport -->
  <proxyTransport>org.apache.juddi.v3.client.transport.JAXWSTransport</proxyTransport>
  <custodyTransferUrl>http://${serverName}:${serverPort}/juddiv3/services/custody-transfer</custodyTransferUrl>
  <inquiryUrl>http://${serverName}:${serverPort}/juddiv3/services/inquiry</inquiryUrl>
  <publishUrl>http://${serverName}:${serverPort}/juddiv3/services/publish</publishUrl>
  <securityUrl>http://${serverName}:${serverPort}/juddiv3/services/security</securityUrl>
  <subscriptionUrl>http://${serverName}:${serverPort}/juddiv3/services/subscription</subscriptionUrl>
  <subscriptionListenerUrl>http://${serverName}:${serverPort}/juddiv3/services/subscription-listener</subscriptionListenerUrl>
  <juddiApiUrl>http://${serverName}:${serverPort}/juddiv3/services/juddi-api?wsdl</juddiApiUrl>
  

  Important

  Pros: This is the standard way of performing UDDI communication and it should should work with all UDDIv3 server implementations.

  Cons: If the server is deployed on the same application server this may lead to issues when auto-registration on deployment/undeployment is used, since the WS stack may become unavailable during undeployment. A workaround is to host the UDDI server on a different server.

Procedure 7.3. Task

1. Open the jUDDI configuration file in a text editor: vi SOA_ROOT/jboss-as/server/PROFILE/deploy/jbossesb-registry.sar/esb.juddi.xml.
2. Edit the settings and set the property <entry key="juddi.jndi.registration">true</entry>. If set to true, RMI methods are registered to jndi and can be searched and called. Default is true.
3. Save the file and exit.
4. Open the UDDI configuration file in a text editor: vi META-INF/uddi.xml.
5. "Comment out" the JAX-WS section of the file and uncomment the RMI section instead.
6. As an optional step, you can also set the java.naming.* properties. In this example, you specified the setting for connecting to jUDDI v3 deployed on a JBoss Application Server. If you like you can instead set the java.naming.* properties in a jndi.properties file, or as system parameters.

   <!-- RMI Transport Settings -->
   <proxyTransport>org.apache.juddi.v3.client.transport.RMITransport</proxyTransport>
   <custodyTransferUrl>/juddiv3/UDDICustodyTransferService</custodyTransferUrl>
   <inquiryUrl>/juddiv3/UDDIInquiryService</inquiryUrl>
   <publishUrl>/juddiv3/UDDIPublicationService</publishUrl>
   <securityUrl>/juddiv3/UDDISecurityService</securityUrl>
   <subscriptionUrl>/juddiv3/UDDISubscriptionService</subscriptionUrl>
   <subscriptionListenerUrl>/juddiv3/UDDISubscriptionListenerService</subscriptionListenerUrl>
   <juddiApiUrl>/juddiv3/JUDDIApiService</juddiApiUrl>
   <javaNamingFactoryInitial>org.jnp.interfaces.NamingContextFactory</javaNamingFactoryInitial>
   <javaNamingFactoryUrlPkgs>org.jboss.naming</javaNamingFactoryUrlPkgs>
   <javaNamingProviderUrl>jnp://${serverName}:1099</javaNamingProviderUrl>
   

   Important

   Pros: It is lightweight fast since it does not need a web service stack.

   Cons: It only works with a jUDDI v3 server implementation.
7. Save the file and exit.

Procedure 7.4. Task

1. Open the UDDI configuration file in a text editor: vi META-INF/uddi.xml.
2. "Comment out" the JAX-WS and RMI Transport sections of the file and uncomment the InVM Transport section instead.

   <!-- InVM -->
   <proxyTransport>org.apache.juddi.v3.client.transport.InVMTransport</proxyTransport>
   <custodyTransferUrl>org.apache.juddi.api.impl.UDDICustodyTransferImpl</custodyTransferUrl>
   <inquiryUrl>org.apache.juddi.api.impl.UDDIInquiryImpl</inquiryUrl>
   <publishUrl>org.apache.juddi.api.impl.UDDIPublicationImpl</publishUrl>
   <securityUrl>org.apache.juddi.api.impl.UDDISecurityImpl</securityUrl>
   <subscriptionUrl>org.apache.juddi.api.impl.UDDISubscriptionImpl</subscriptionUrl>
   <subscriptionListenerUrl>org.apache.juddi.api.impl.UDDISubscriptionListenerImpl</subscriptionListenerUrl>
   <juddiApiUrl>org.apache.juddi.api.impl.JUDDIApiImpl</juddiApiUrl>
   

   Important

   Pros: It is lightweight and provides the best performance for communications and there are no deployment order issues when using auto-registration of services during deployment and undeployment.

   Cons: It will only work with a jUDDI v3 server implementation. Normally, you would use a jUDDI server for each application server sharing one common database.
3. Save the file and exit.

• Call the following method prior to making any other calls to it: Registry.start()

Procedure 7.5. Task

• Call the following method prior to making any other calls to it: Registry.stop()

Procedure 7.6. Task

• Use the UDDIService annotation to register a service under an already-existing business in the Registry. The annotation should be added to the Java class' "class" level.

Procedure 7.7. Task

• Use the UDDIServiceBinding annotation to register an end-point reference in the Service Registry. The annotation should be added to the Java class' "class" level.

  Note

  You cannot use this annotation by itself. It needs to be utilised within an UDDIService annotation

Procedure 7.8. Task

1. Add an annotation to any class that defines a service. Here is an example where they are added to a web service POJO with a JAX-WS Webservice annotation:

   package org.apache.juddi.samples;
   
   import javax.jws.WebService;
   import org.apache.juddi.v3.annotations.UDDIService;
   import org.apache.juddi.v3.annotations.UDDIServiceBinding;
   
   @UDDIService(businessKey="uddi:myBusinessKey", serviceKey="uddi:myServiceKey", description = "Hello World test service")
   @UDDIServiceBinding(bindingKey="uddi:myServiceBindingKey", description="WSDL endpoint for the helloWorld Service. This service is used for "
         + "testing the jUDDI annotation functionality",
       accessPointType="wsdlDeployment", accessPoint="http://localhost:8080/juddiv3-samples/services/helloworld?wsdl")
   @WebService(endpointInterface = "org.apache.juddi.samples.HelloWorld", serviceName = "HelloWorld")
   
   public class HelloWorldImpl implements HelloWorld {
       public String sayHi(String text) {
           System.out.println("sayHi called");
           return "Hello " + text;
       }
   }
   

   On deployment of this WebService, the juddi-client code will scan this class for UDDI annotations and take care of the registration process.
2. Open the uddi.xml file in your text editor: vi uddi.xml
3. Scroll down to the "clerk" section and add a reference to the org.apache.juddi.samples.HelloWorldImpl service class:

   <clerks registerOnStartup="true">
     <clerk name="BobCratchit" node="default" publisher="bob" password="bob"> 
       <class>org.apache.juddi.samples.HelloWorldImpl</class>  
     </clerk>
   </clerks>
   

   In this example, Bob is using the connection setting for the node named "default". Furthermore, he will be using a publisher named "bob", for which the password is also "bob".
4. Save the file and exit.

Procedure 7.9. Task

1. Open the jUDDI client configuration file in a text editor: vi SOA_ROOT/jboss-as/server/PROFILE/deploy/jbossesb-registry.sar/esb.juddi.xml. Use this file as a template for your own uddi.xml file.
2. Make sure the clerk manager points to your custom uddi.xml when it is instantiated:

   UDDIClerkManager clerkManager = new UDDIClerkManager("META/myuddi.xml");
   clerkManager.start();
   
   UDDIClerk clerk = clerkManager.getClientConfig().getUDDIClerks().get(clerkName);
   

   Note

   A UDDIClerk will allow you do make authenticated requests to a UDDI server.

Procedure 7.10. Task

1. Use the code in the org.apache.juddi.v3.client.mapping package.
2. Make the following call to asynchronously register your web service end point:

   //Add the properties from the uddi.xml
   properties.putAll(clerk.getUDDINode().getProperties());
   RegistrationInfo registrationInfo = new RegistrationInfo();
   registrationInfo.setServiceQName(serviceQName);
   registrationInfo.setVersion(version);
   registrationInfo.setPortName(portName);
   registrationInfo.setServiceUrl(serviceUrl);
   registrationInfo.setWsdlUrl(wsdlURL);
   registrationInfo.setWsdlDefinition(wsdlDefinition);
   registrationInfo.setRegistrationType(RegistrationType.WSDL);
   registration = new AsyncRegistration(clerk, urlLocalizer, properties, registrationInfo);
   Thread thread = new Thread(registration);
   thread.start();
   

   Note

   This does assume that you can pass in a URL to the WSDL file in addition to the WSDLDefinition. In most cases you will need to package the WSDL file you wish to register in your deployment.

   To obtain a WSDLDefinition use this code:

   ReadWSDL readWSDL = new ReadWSDL();
   Definition definition = readWSDL.readWSDL("wsdl/HelloWorld.wsdl");
   

   You need to pass the path information to the WSDL that is on the classpath.

Procedure 7.11. Task

• To remove a WSDL binding from the service registry, use this code:

  WSDL2UDDI wsdl2UDDI = new WSDL2UDDI(clerk, urlLocalizer, properties);
  String serviceKey = wsdl2UDDI.unRegister(serviceName, portName, serviceURL);
  

  Note

  If this is the last BindingTemplate for the BusinessService it will also remove the BusinessService itself along with the WSDLPortType and WSDLBinding TModels. The lifecycle is set to "registration" on deployment of the end point and set to "unregistration" on removal of the end point.

Procedure 7.12. Task

1. Use the code in the org.apache.juddi.v3.client.mapping package.
2. Make the following call to asynchronously register your web service end point:

   //Add the properties from the uddi.xml
   properties.putAll(clerk.getUDDINode().getProperties());
   RegistrationInfo registrationInfo = new RegistrationInfo();
   registrationInfo.setServiceQName(serviceQName);
   registrationInfo.setVersion(version);
   registrationInfo.setPortName(portName);
   registrationInfo.setServiceUrl(serviceUrl);
   registrationInfo.setWsdlUrl(wsdlURL);
   registrationInfo.setWsdlDefinition(wsdlDefinition);
   registrationInfo.setRegistrationType(RegistrationType.BPEL);
   registration = new AsyncRegistration(clerk, urlLocalizer, properties, registrationInfo);
   Thread thread = new Thread(registration);
   thread.start();
   

   Set the RegistrationInfo.RegistrationType to RegistrationType.BPEL.

Procedure 7.13. Task

• To locate a service binding using the service locator, use this code:

  ServiceLocator serviceLocator = new ServiceLocator(clerk, urlLocalizer, properties);
  String endPointURL = serviceLocator.lookupEndpoint(serviceQName, String portName);
  

  Note

  The downside of doing a look-up prior to each service invocation is that it will be detrimental to performance.

Procedure 7.14. Task

1. Obtain the sample code located in the uddi-client module.
2. Make a call to the Registry to obtain an authentication token. (The following code is taken from the unit tests in this module):

   public void testAuthToken() {
       try {
           String clazz = ClientConfig.getConfiguration().getString(
               Property.UDDI_PROXY_TRANSPORT,Property.DEFAULT_UDDI_PROXY_TRANSPORT);
           Class<?> transportClass = Loader.loadClass(clazz);
           if (transportClass!=null) {
               Transport transport = (Transport) transportClass.newInstance();
               UDDISecurityPortType securityService = transport.getSecurityService();
               GetAuthToken getAuthToken = new GetAuthToken();
               getAuthToken.setUserID("root");
               getAuthToken.setCred("");
               AuthToken authToken = securityService.getAuthToken(getAuthToken);
               System.out.println(authToken.getAuthInfo());
               Assert.assertNotNull(authToken);
           } else {
               Assert.fail();
           }
       } catch (Exception e) {
           e.printStackTrace();
           Assert.fail();
       } 
   }
   

   Note

   Ensure that you supply the correct credentials for the root publisher to obtain a successful response.