JAXR provides a uniform and standard Java API for accessing XML registries. It is included in Sun's Web Services Developer Pack version 1.0. JAXR removes the dependence between applications and nonstandard toolkits by giving developers a rich, simple, and standard extension API to communicate with registry providers using these very same open standards.
A naming service allows a name to be associated with an object and the object to be located by that name. A similiar concept like a DNS service. It holds a mapping between a domain name and an IP address. For example, you can send a query for www.javacamp.org and a DNS server will return the IP address 208.170.149.158.
A registry is a special form of a naming service. It not only allows a lookup, but also allows objects to be registered. The remote method invocation (RMI) registry and the Java Naming and Directory Interface(JNDI) API are two examples of Java registry and lookup services. When you develop a remote object and register it in the registry by associating it with a name. Other applications may use the JNDI API or RMI naming service to query that registry for the name and get a remote reference (or a stub) back for the remote object.
A registry in the context of Web services essentially provides this same functionality. Registries give applciations and business a place to store information about their Web services and give clients the ability to query and retrieve details about such business. Every registry has an information model and a set of registry services.
Universal Description, Discovery, and Integration(UDDI) and the Electronic Business Extensible Markup Language(ebXML) are two dominant industry standands for Web services. Java developers need a standard API to access these heterogeneous registries from Java. This is how JAXR comes in.
The JAXR architecture is based on the concept of pluggable providers. JAXR provides a layer of abstraction to developers. Developers write applications using a standand JAXR client API and a standard JAXR information model to interact with business registries of UDDI and ebXML.
JAXR has two capability levels:
All JAXR providers are required to support level 0. Support for level 1 is optional.
The JAXR's information mode is contained in the javax.xml.registry.infomodel package, and at its core is a javax.xml.registry.infomodel.RegistryObject. All objects in the registry implement the RegistryObject, and essentially everything in the registry is a RegistryObject.
UDDI specifications require that a UDDI provider expose the registry though a Web-based HTML interface. Developers can use eithre this interface or the JAXR API.
In order to show it clearly, we explain the steps with a piece of code. You may need to download Java XML(JAX) pack from http://java.sun.com/xml
Before publish to UDDI, you may need to do the following steps:
import javax.xml.registry.infomodel.*;
import javax.xml.registry.*;
import java.util.*;
import java.net.PasswordAuthentication;
public class Publish2UDDI {
private static final String QUERY_URL= "http:...";
private static final String PUBLISH_URL="http:...";
private static String uddiUserName;
private static String uddiPassword;
public static void main(String[] args) {
//set the properties for the ConnectionFactory
Properties enviro = new Properties();
enviro.setProperty("javax.xml.registry.queryManagerURL", QUERY_URL);
enviro.setProperty("javax.xml.registry.lifeCycleManagerURL", PUBLISH_URL);
enviro.setProperty("javax.xml.registry.factoryClass", com.sun.xml.registry.uddi.ConnectionFactoryImpl");
//create a connection
ConnectionFactory confac = ConnectionFactory.newInstance();
confac.setProperties(enviro);
Connection conn = confac.createConnection();
//Authernticate the UDDI userName and Password
PasswordAuthentication passwdAuth = new PasswordAuthentication(uddiUserName, uddiPassword.toCharArray());
Set credentials = new HashSet();
credentials.add(passwdAuth);
conn.setCredentials(credentials);
//Obtain a reference to the RegistryService, BusinessLifeCycleManager and the BusinessQueryManger
RegistryService registryservice = conn.getRegistryService();
BusinessLifeCycleManager lifecyclemgr = registryservice.getBusinessLifeCycleManager();
BusinessQueryManager querymgr = registryservice.getBusinessQueryManager();
Then, there are five steps involved:
//Create an organization object
Organization company = lifecyclemgr.createOrganization("The organization name needed to be registered");
InternationalString description = lifecyclemgr.createInternationalString("Description of your organization");
//Create a user object
User contact = lifecyclemgr.createUser();
PersonName name = lifecyclemgr.createPersonName("Owner's Name");
contact.setPersonName(name);
//create and set the users telephone number
TelephoneNumber telnum = lifecyclemgr.createTelephoneNumber();
telnum.setNumber("1800-000-0000");
Collection phonenumbers = new ArrayList();
phonenumbers.add(telnum);
contact.setTelephoneNumber(phonenumbers);
//create and set the users email address
EmailAddress email = lifecyclemgr.createEmailAddress("someone@someplace.somedom");
Collection emaillist = new ArrayList();
emaillist.add(email);
contact.setEmailAddresses(emaillist);
//set the user as the primary contact for the organizaton
company.setPrimaryContact(contact);
//Create the web service object
Collection servicelist = new ArrayList();
Service service = lifecyclemgr.createService("Service Name");
InternationalString serviceDescription = lifecyclemgr.createInternationalString("Description..");
service.setDescription(serviceDescription);
//Create the web service bindings
Collection serviceBindigs = new ArrayList();
ServiceBinding binding = lifecyclemgr.createServiceBinding();
InternationalString bindingDescription = lifecyclemgr.createInternationalString("Say sth here..");
binding.setDescription(bindingDescription);
binding.setAccessURI("http://www.companysName.org");
serviceBindings.add(binding);
service.addserviceBindings(serviceBindings);
servicelist.add(service);
company.addServices(servicelist);
//Classify the organization
ClassificationScheme scheme = querymgr.findClassificationSchemeByName("xxx");
Classification classification = (Classfication)lifecyclemgr.createClassification(scheme, "catalogue name", "catalogue number");
Collection classficationlist = new ArrayList();
classificationlist.add(classification);
company.addClassfications(classificationlist);
Collection organizationlist = new ArrayList();
organizationlist.add(company);
//make the final call to the registry and get a response
BulkResponse response = lifecyclemgr.saveOrganizations(organizationlist);
Collection exceptions = response.getException();
if(exceptions == null) {
Collection keys = response.getCollection();
Iterator iterator = keys.iterator();
Key key = (Key) iterator.next();
String uid = key.getId();
company.setKey(key);
}
else {// there is an exception
Iterator iterator = exceptions.iterator();
while(iterator.hasNext()) {
Exception exception = (Exception) iterator.next();
System.out.println("Exception...." + exception);
}
}
conn.close();
}catch(Exception e) {}
}
}
}
A registry can be queried for different fields: Organization, Concepts, ServiceBindings, Service, Associations, and so on. by using the relevant methods from the BusinessQuery Manager interface.
There are five steps involved:
Details in coding are omitted