Two bindings from XML to Java code

Listing 3. The generateClasses () method

public void generateClasses (URL schemaURL) throws IOException {/ *** Create builder to generate JDOM representation of XML Schema, * without validation and using Apache Xerces * / SAXBuilder builder = new SAXBuilder ();. try {Document schemaDoc = builder.build (schemaURL); // Handle complex typesList complexTypes = schemaDoc.getRootElement () getChildren ( "complexType", schemaNamespace);. for (Iterator i = complexTypes.iterator (); i.hasNext ();) {// Iterate and handleElement ComplexType = (ELEMENT) i.Next (); handleComplexType (complexType);}} catch (jdomexception e) {throw new oException (E.getMessage ());}}

For the sake of simplicity, it will emphasize some key points, not the entire process of converting Schema to the Java class. You can view the full SchemAmApper class online, or you can download it. The generator must determine that each ComplexType element found in XML Schema is an explicit (with "type" attribute) or implicit (without "type" properties). If the type is explicit, the type will be the interface name, and the initial capital is capitalized. If the type is implicit, the interface name will be constructed according to the characteristic name. The code segment for processing this logic is displayed in Listing 4. (To learn more about data binding, see the sidebar, the term explanation.) Listing 4. Determine the interface name // determine if this is an expedition or implicit typeString type = null; // handle extension, if NeededString BaseType = null; try {// Assume that we are dealing with an explicit typetype = complexType.getAttribute ( "name") getValue ();.} catch (NoSuchAttributeException e) {/ ** It is safe with an implicit type to assume that THE PARENT * IS OF TYPE "Element", HAS No "Type" Attribute, And That We * Can Derive The Type as The value of the element's "name" * attribute with the word "type" appended to it. * / try { .. type = new StringBuffer () append (.. BindingUtils.initialCaps (complexType.getParent () getAttribute ( "name") getValue ())) append ( "type") toString ();.} catch (NoSuchAttributeException nsae) { //Houldn't happen in schema-valid documentsthrow new oew oException ("All Elements Must At Have A Name);}}

Therefore, according to the naming convention in the code, an element with a serviceconfiguration type will generate a Java interface called ServiceConfiguration. Elements called Port but there is no explicit type will generate a Java interface called PortType. It uses the element name (port) to transfer the initials to uppercase (port), plus the words TYPE, get PortType. Similarly, all implementations use the interface name and then add a abbreviation IMPL. So, the final implementation class is ServiceConfigurationImpl and PortTypeImpl. With these naming conventions, you can easily determine which Java classes that map data constraints to the Java interface. If the application is set in the runtime, the class loader or other utility can quickly determine if the required class is installed. Class loaders or utilities As long as you find the generated class name from XML Schema, you can try to load them. Named logic is determined in advance, so it is very convenient to check. Once the name is determined, an interface and an implementation class can be generated (see Listing 5). 5. Generate Code Listing StringBuffer interfaceCode = new StringBuffer (); StringBuffer implementationCode = new StringBuffer ();. / ** Start writing out the interface and implementation class * definitions * / interfaceCode.append ( "public interface") .append (interfaceName ); // add in extension if appropriateif (BaseType! = Null) {interfaceCode.Append ("Extends") .append (basetype);} interfacecode.Append ("{/ {"; "{//10) ) .append (implementationName); // Add in extension if appropriateif (baseType = null) {implementationCode.append ( "extends") .append (baseType) .append ( "Impl");}! implementationCode.append ( "implements" ) .append ("{// n"); // add in proties and methods // close Up interface and ustementation classinterfacecode.append ("}"); ImplementationCode.Append ("}");

In fact, generating properties and methods are quite simple. Add the interface and the corresponding name of the corresponding implementation to the memory of the class, then the right broth, and their role is the end class. Like this pair of pairs, rather than separately generate classes, will simultaneously reflect the process on the interface and implementation. Check the source code (see Resources), you can get enough explanation. The bold annotation in Listing 5 represents multiple lines of code in the source list. The streamlined code here is to keep it simple. For each feature of XML Schema (represented by Schema Attribute), the read method and write method are added to the interface and implementation (implementation of the code logic). At the same time, variables will be added to the code of the class. The final result is a class that is generated in the first part of this series. Where they can be viewed or downloaded along with the rest of the code in this article (see Resources): ServiceConfiguration.java ServiceConfigurationImpl.java PortType.java PortTypeImpl.java DocumentType.java DocumentTypeImpl.java WebServiceConfiguration.java WebServiceConfigurationImpl.java two auxiliary The program class will also participate in class generation: bindingutils, turn the initials into capital. Although this method can be added to the generator class, but I plan to use this method in the package and dispenser class, so I will return it to this auxiliary program class. You can view BindingUtils online, or you can download it. DataMapping, SchemamApper class is used to convert data types. You can view the source code or download the source code online. Complete the package such as many other open source software, the data binding package shown here is a work in progress. Although it has already taken a scale, there is still a lot of space available to add more features and improvements. Therefore, based on this code, there are many ways to be derived in applications. This sample code can be reused to convert the data constraints of XML Schema into type secure JAVA interfaces and implementations. For example, so far, sample code has not been processed in XML Schema. For many XML developers, those data ranges are the real cause of Schema. Then consider the expansion XML Schema of the web service in Listing 6. Listing 6. Web service configuration with expansion constraints

Listing 6 illustrates the type of Number property, and specifies the legal scope of the value in a few lines emphasized (1 to 32, 767) ). These additional declarations will ignore the current version of SchemAmAPper. When creating a Java interface from Schema, it is not necessary to handle the Minxxx and Maxxxx keywords in XML Schema, but they can increase considerable additional verification. Check out the code example in Listing 7, which can be generated in the implementation class to ensure that only the value in the schema specified range can be used as a variable. Listing 7. Generating code with range check

public class PortTypeImpl implements PortType {private String protocol; private int number; private String protected; public void setNumber (int number) {if ((number> 0) && (number <= 32767)) {this.number = number;} else {throw IllegalArgumentException ( "Argument must be greater than 0and less than or equal to 32767");}} public int getNumber () {return number;} public void setProtocol (String protocol) {this.protocol = protocol;} public String getProtocol () {Return protocol;} public void setprotected (String protected) {this.protaced = protected;}} public string getprotected ()}