<!doctype HTML public "-//W3C//DTD HTML 4.0 Frameset//EN">
<!-- Copyright 2004 The Apache Software Foundation

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License. -->
<html>
<head>
<!-- InstanceBeginEditable name="doctitle" -->
<title>Getting Started with XMLBeans</title>
<!-- InstanceEndEditable -->
<!--(Meta)==========================================================-->

<meta http-equiv=Content-Type content="text/html; charset=$CHARSET;">


<!-- InstanceBeginEditable name="metatags" -->

<meta name="author" content="your name">
<meta name="description" content="A description of the topic contents.">
<meta name="keywords" content="keywords to help in searches">
<meta name="date last modified" content="10/25/02">
<!-- InstanceEndEditable -->

<!--(Links)=========================================================-->
<!-- InstanceBeginEditable name="head" -->
<link href="../xmlbeans.css" rel="stylesheet" type="text/css">
<!-- InstanceEndEditable -->
<link href="../xmlbeans.css" rel="stylesheet" type="text/css">
<a href="../../../core/index.html" id="index"></a>
<script language="JavaScript" src="../../../core/topicInfo.js"></script>
<script language="JavaScript" src="../../../core/CookieClass.js"></script>
<script language="JavaScript" src="../../../core/displayContent.js"></script>
</head>

<!--(Body)==========================================================-->
<body>
<script language="JavaScript">

</script>
<!-- InstanceBeginEditable name="body" -->
<h1> Getting Started with XMLBeans</h1>
<div id="topictext">
  <p>XMLBeans provides intuitive ways to handle XML that make it easier for you
    to access and manipulate XML data and documents in Java. </p>
  <p>Characteristics of XMLBeans approach to XML:</p>
</div>
<ul>
  <li>
    <div>It provides a familiar Java object-based view of XML data without losing
      access to the original, native XML structure.</div>
  </li>
  <li>
    <div>The XML's integrity as a document is not lost with XMLBeans. XML-oriented
      APIs commonly take the XML apart in order to bind to its parts. With XMLBeans,
      the entire XML instance document is handled as a whole. The XML data is
      stored in memory as XML. This means that the document order is preserved
      as well as the original element content with whitespace.</div>
  </li>
  <li>
    <div>With types generated from schema, access to XML instances is through
      JavaBean-like accessors, with get and set methods.</div>
  </li>
  <li>
    <div>It is designed with XML schema in mind from the beginning &#8212; XMLBeans
      supports all XML schema definitions.</div>
  </li>
  <li>Access to XML is fast.</li>
</ul>
<div>
  <p>The starting point for XMLBeans is XML schema. A schema (contained in an
    XSD file) is an XML document that defines a set of rules to which other XML
    documents must conform. The XML Schema specification provides a rich data
    model that allows you to express sophisticated structure and constraints on
    your data. For example, an XML schema can enforce control over how data is
    ordered in a document, or constraints on particular values (for example, a
    birth date that must be later than 1900). Unfortunately, the ability to enforce
    rules like this is typically not available in Java without writing custom
    code. XMLBeans honors schema constraints.</p>
  <p class="notepara"><strong>Note:</strong> Where an XML schema defines rules
    for an XML document, an XML <em>instance</em> is an XML document that conforms
    to the schema.</p>
  <p>You compile a schema (XSD) file to generate a set of Java interfaces that
    mirror the schema. With these types, you process XML instance documents that
    conform to the schema. You bind an XML instance document to these types; changes
    made through the Java interface change the underlying XML representation.</p>
  <p>Previous options for handling XML include using XML programming interfaces
    (such as DOM or SAX) or an XML marshalling/binding tool (such as JAXB). Because
    it lacks strong schema-oriented typing, navigation in a DOM-oriented model
    is more tedious and requires an understanding of the complete object model.
    JAXB provides support for the XML schema specification, but handles only a
    subset of it; XMLBeans supports all of it. Also, by storing the data in memory
    as XML, XMLBeans is able to reduce the overhead of marshalling and demarshalling.</p>
  <h1>Accessing XML Using Its Schema</h1>
  <p>To get a glimpse of the kinds of things you can do with XMLBeans, take a
    look at an example using XML for a purchase order. The purchase order XML
    contains data exchanged by two parties, such as two companies. Both parties
    need to be able to rely on a consistent message shape, and a schema specifies
    the common ground. </p>
  <p>Here's what a purchase order XML instance might look like.</p>
  <pre>
&lt;po:purchase-order xmlns:po="http://openuri.org/easypo"&gt;
    &lt;po:customer&gt;
        &lt;po:name&gt;Gladys Kravitz&lt;/po:name&gt;
        &lt;po:address&gt;Anytown, PA&lt;/po:address&gt;
    &lt;/po:customer&gt;
    &lt;po:date&gt;2003-01-07T14:16:00-05:00&lt;/po:date&gt;
    &lt;po:line-item&gt;
        &lt;po:description&gt;Burnham's Celestial Handbook, Vol 1&lt;/po:description&gt;
        &lt;po:per-unit-ounces&gt;5&lt;/po:per-unit-ounces&gt;
        &lt;po:price&gt;21.79&lt;/po:price&gt;
        &lt;po:quantity&gt;2&lt;/po:quantity&gt;
    &lt;/po:line-item&gt;
    &lt;po:line-item&gt;
        &lt;po:description&gt;Burnham's Celestial Handbook, Vol 2&lt;/po:description&gt;
        &lt;po:per-unit-ounces&gt;5&lt;/po:per-unit-ounces&gt;
        &lt;po:price&gt;19.89&lt;/po:price&gt;
        &lt;po:quantity&gt;2&lt;/po:quantity&gt;
    &lt;/po:line-item&gt;
&lt;po:shipper&gt;
        &lt;po:name&gt;ZipShip&lt;/po:name&gt;
        &lt;po:per-ounce-rate&gt;0.74&lt;/po:per-ounce-rate&gt;
    &lt;/po:shipper&gt;
&lt;/po:purchase-order&gt;</pre>
  <p>This XML includes a root element, <span class="langinline">purchase-order</span>,
    that has three kinds of child elements: <span class="langinline">customer</span>,
    <span class="langinline">date</span>, <span class="langinline">line-item</span>,
    and <span class="langinline">shipper</span>. An intuitive, object-based view
    of this XML would provide an object representing the <span class="langinline">purchase-order</span>
    element, and it would have methods for getting the date and for getting subordinate
    objects for <span class="langinline">customer</span>, <span class="langinline">line-item</span>,
    and <span class="langinline">shipper</span> elements. Each of the last three
    would have its own methods for getting the data inside them as well.</p>
  <h2>Looking at the Schema</h2>
  <p>The following XML is the the schema for the preceding purchase order XML.
    It defines the XML's &quot;shape&quot; &#8212; what its elements are, what
    order they appear in, which are children of which, and so on.</p>
</div>
<div>
  <pre>
&lt;xs:schema targetNamespace="http://openuri.org/easypo"
    xmlns:po="http://openuri.org/easypo"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    elementFormDefault="qualified"&gt;

    &lt;xs:element name="purchase-order"&gt;
        &lt;xs:complexType&gt;
            &lt;xs:sequence&gt;
                &lt;xs:element name="customer" type="po:customer"/&gt;
                &lt;xs:element name="date" type="xs:dateTime"/&gt;
                &lt;xs:element name="line-item" type="po:line-item" minOccurs="0" maxOccurs="unbounded"/&gt;
                &lt;xs:element name="shipper" type="po:shipper" minOccurs="0"/&gt;
            &lt;/xs:sequence&gt;
        &lt;/xs:complexType&gt;
    &lt;/xs:element&gt;
    &lt;xs:complexType name="customer"&gt;
        &lt;xs:sequence&gt;
            &lt;xs:element name="name" type="xs:string"/&gt;
            &lt;xs:element name="address" type="xs:string"/&gt;
        &lt;/xs:sequence&gt;
    &lt;/xs:complexType&gt;
    &lt;xs:complexType name="line-item"&gt;
        &lt;xs:sequence&gt;
            &lt;xs:element name="description" type="xs:string"/&gt;
            &lt;xs:element name="per-unit-ounces" type="xs:decimal"/&gt;
            &lt;xs:element name="price" type="xs:double"/&gt;
            &lt;xs:element name="quantity" type="xs:int"/&gt;
        &lt;/xs:sequence&gt;
    &lt;/xs:complexType&gt;
    &lt;xs:complexType name="shipper"&gt;
        &lt;xs:sequence&gt;
            &lt;xs:element name="name" type="xs:string"/&gt;
            &lt;xs:element name="per-ounce-rate" type="xs:decimal"/&gt;
        &lt;/xs:sequence&gt;
    &lt;/xs:complexType&gt;
&lt;/xs:schema&gt;</pre>
  <div>
    <p>This schema describes the purchase order XML instance by defining the following:</p>
  </div>
  <ul>
    <li>
      <div>Definitions for three complex types &#8212; customer, line-item, and
        shipper. These are the types used for the children of the purchase-order
        element. In schema, a complex type is one that defines an element that
        may have child elements and attributes. The sequence element nested in
        the complex type lists its child elements.</div>
      <p>These are also <em>global</em> types. They are global because they are
        at the top level of the schema (in other words, just beneath the <span class="langinline">schema</span>
        root element). This means that they may be referenced from anywhere else
        in the schema.</p>
    </li>
  </ul>
</div>
<div>
  <ul>
    <li>Use of simple types within the complex types. The name, address, and description
      elements (among others) are typed as simple types. As it happens, these
      are also <em>built-in</em> types. A built-in type (here, one with the &quot;xs&quot;
      prefix) is part of the schema specification. (The specification defines
      46 built-in types.)</li>
    <li>A global element called purchase-order. This element definition includes
      a nested complex type definition that specifies the child elements for a
      purchase-order element. Notice that the complex type includes references
      to the other complex types defined in this schema.</li>
  </ul>
  <div></div>
  <p>In other words, the schema defines types for the child elements and describes
    their position as subordinate to the root element, <span class="langinline">purchase-order</span>.</p>
  <p>When you use the XMLBean compiler with an XSD file such as this one, you
    generate a JAR file containing the interfaces generated from the schema.</p>
  <h2>Writing Java Code That Uses the Interfaces</h2>
  <p>With the XMLBeans interfaces in your application, you can write code that
    uses the new types to handle XML based on the schema. Here's an example that
    extracts information about each of the ordered items in the purchase order
    XML, counts the items, and calculates a total of their prices. In particular,
    look at the use of types generated from the schema and imported as part of
    the <span class="langinline">org.openuri.easypo</span> package. </p>
  <p>The <span class="langinline">printItems</span> method receives a <span class="langinline">File</span>
    object containing the purchase order XML file.</p>
  <pre>
package docs.xmlbeans;

import java.io.File;
import org.apache.xmlbeans.*;
import org.openuri.easypo.PurchaseOrderDocument;
import org.openuri.easypo.PurchaseOrder;
import org.openuri.easypo.LineItem;

public class POHandler
{
    public static void printItems(File po) throws Exception
    {
        /*
         * All XMLBeans schema types provide a nested Factory class you can
         * use to bind XML to the type, or to create new instances of the type.
         * Note that a "Document" type such as this one is an XMLBeans
         * construct for representing a global element. It provides a way
         * for you to get and set the contents of the entire element.
         *
         * Also, note that the parse method will only succeed if the
         * XML you're parsing appears to conform to the schema.
         */
        PurchaseOrderDocument poDoc =
            PurchaseOrderDocument.Factory.parse(po);

        /*
         * The PurchaseOrder type represents the purchase-order element's
         * complex type.
         */
        PurchaseOrder po = poDoc.getPurchaseOrder();

        /*
         * When an element may occur more than once as a child element,
         * the schema compiler will generate methods that refer to an
         * array of that element. The line-item element is defined with
         * a maxOccurs attribute value of "unbounded", meaning that
         * it may occur as many times in an instance document as needed.
         * So there are methods such as getLineItemArray and setLineItemArray.
         */
        LineItem[] lineitems = po.getLineItemArray();
        System.out.println("Purchase order has " + lineitems.length + " line items.");

        double totalAmount = 0.0;
        int numberOfItems = 0;

        /*
         * Loop through the line-item elements, using generated accessors to
         * get values for child elements such a description, quantity, and
         * price.
         */
        for (int j = 0; j < lineitems.length; j++)
        {
            System.out.println(" Line item: " + j);
            System.out.println(
                "   Description: " + lineitems[j].getDescription());
            System.out.println("   Quantity: " + lineitems[j].getQuantity());
            System.out.println("   Price: " + lineitems[j].getPrice());
            numberOfItems += lineitems[j].getQuantity();
            totalAmount += lineitems[j].getPrice() * lineitems[j].getQuantity();
        }
        System.out.println("Total items: " + numberOfItems);
        System.out.println("Total amount: " + totalAmount);
    }
}
</pre>
  <p>Notice that types generated from the schema reflect what's in the XML:</p>
</div>
<ul>
  <li>
    <div>A <span class="langinline">PurchaseOrderDocument</span> represents the
      global root element.</div>
  </li>
  <li>
    <div>A <span class="langinline">getPurchaseOrder</span> method returns a <span class="langinline">PurchaseOrderDocument.PurchaseOrder</span>
      type that contains child elements, including <span class="langinline">line-item</span>.
      A <span class="langinline">getLineItemArray</span> method returns a <span class="langinline">LineItem</span>
      array containing the <span class="langinline">line-item</span> elements.</div>
  </li>
  <li>Other methods, such as <span class="langinline">getQuantity</span>, <span class="langinline">getPrice</span>,
    and so on, follow naturally from what the schema describes, returning corresponding
    children of the <span class="langinline">line-item</span> element.</li>
  <li>The name of the package containing these types is derived from the schema's
    target namespace.</li>
</ul>
<div>
  <p>Capitalization and punctuation for generated type names follow Java convention.
    Also, while this example parses the XML from a file, other <span class="langinline">parse</span>
    methods support a Java <span class="langinline">InputStream</span> object,
    a <span class="langinline">Reader</span> object, and so on.</p>
  <p>The preceding Java code prints the following to the console:</p>
</div>
<div>
  <pre>
Purchase order has 3 line items.
 Line item 0
   Description: Burnham's Celestial Handbook, Vol 1
   Quantity: 2
   Price: 21.79
 Line item 1
   Description: Burnham's Celestial Handbook, Vol 2
   Quantity: 2
   Price: 19.89
Total items: 4
Total amount: 41.68</pre>
  <h2>Creating New XML Instances from Schema</h2>
  <p>As you've seen XMLBeans provides a &quot;factory&quot; class you can use
    to create new instances. The following example creates a new <span class="langinline">purchase-order</span>
    element and adds a <span class="langinline">customer</span> child element.
    It then inserts <span class="langinline">name</span> and <span class="langinline">address</span>
    child elements, creating the elements and setting their values with a single
    call to their <span class="langinline">set</span> methods.</p>
  <pre>
public PurchaseOrderDocument createPO()
{
&nbsp;&nbsp;&nbsp;&nbsp;PurchaseOrderDocument newPODoc = PurchaseOrderDocument.Factory.newInstance();
&nbsp;&nbsp;&nbsp;&nbsp;PurchaseOrder newPO = newPODoc.addNewPurchaseOrder();
&nbsp;&nbsp;&nbsp;&nbsp;Customer newCustomer = newPO.addNewCustomer();
&nbsp;&nbsp;&nbsp;&nbsp;newCustomer.setName(&quot;Doris Kravitz&quot;);
&nbsp;&nbsp;&nbsp;&nbsp;newCustomer.setAddress(&quot;Bellflower, CA&quot;);
&nbsp;&nbsp;&nbsp;&nbsp;return newPODoc;
}
</pre>
  <p>The following is the XML that results. Note that XMLBeans assigns the correct
    namespace based on the schema, using an &quot;ns1&quot; (or, &quot;namespace
    1&quot;) prefix. For practical purposes, the prefix itself doesn't really
    matter &#8212; it's the namespace URI (http://openuri.org/easypo) that defines
    the namespace. The prefix is merely a marker that represents it.</p>
  <pre>&lt;ns1:purchase-order xmlns:ns1=&quot;http://openuri.org/easypo&quot;&gt;
&nbsp;&nbsp;&nbsp;&nbsp;&lt;ns1:customer&gt;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;ns1:name&gt;Doris Kravitz&lt;/ns1:name&gt;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;ns1:address&gt;Bellflower, CA&lt;/ns1:address&gt;
&nbsp;&nbsp;&nbsp;&nbsp;&lt;/ns1:customer&gt;
&lt;/ns1:purchase-order&gt;
</pre>
  <p>Note that all types (including those generated from schema) inherit from
    <span class="langinline">XmlObject</span>, and so provide a <span class="langinline">Factory</span>
    class. For an overview of the type system in which <span class="langinline">XmlObject</span>
    fits, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support
    for Built-In Schema Types</a>. For reference information, see <a href="../reference/org/apache/xmlbeans/XmlObject.html">XmlObject
    Interface</a>.</p>
  <h1>XMLBeans Hierarchy</h1>
  <p>The generated types you saw used in the preceding example are actually part
    of a hierarchy of XMLBeans types. This hierarchy is one of the ways in which
    XMLBeans presents an intuitive view of schema. At the top of the hierarchy
    is <span class="langinline">XmlObject</span>, the base interface for XMLBeans
    types. Beneath this level, there are two main type categories: generated types
    that represent user-derived schema types, and included types that represent
    built-in schema types.</p>
  This topic has already introduced generated types. For more information, see
  <a href="conJavaTypesGeneratedFromUserDerived.html">Java Types Generated from
  User-Derived Schema Types.</a>
  <h2>Built-In Type Support</h2>
  <p>In addition to types generated from a given schema, XMLBeans provides 46
    Java types that mirror the 46 built-in types defined by the XML schema specification.
    Where schema defines <span class="langinline">xs:string</span>, <span class="langinline">xs:decimal</span>,
    and <span class="langinline">xs:int</span>, for example, XMLBeans provides
    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlString.html">XmlString</a></span>,
    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlDecimal.html">XmlDecimal</a></span>,
    and <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlInt.html">XmlInt</a></span>.
    Each of these also inherits from <span class="langinline">XmlObject</span>,
    which corresponds to the built-in schema type <span class="langinline">xs:anyType</span>.</p>
  <p>XMLBeans provides a way for you to handle XML data as these built-in types.
    Where your schema includes an element whose type is, for example, <span class="langinline">xs:int</span>,
    XMLBeans will provide a generated method designed to return an <span class="langinline">XmlInt</span>.
    In addition, as you saw in the preceding example, for most types there will
    also be a method that returns a natural Java type such as <span class="langinline">int</span>.
    The following two lines of code return the <span class="langinline">quantity</span>
    element's value, but return it as different types.</p>
  <pre>
// Methods that return simple types begin with an "x".
XmlInt xmlQuantity = lineitems[j].xgetQuantity();
// Methods that return a natural Java type are unadorned.
int javaQuantity = lineitems[j].getQuantity();
</pre>
  <p>In a sense both get methods navigate to the <span class="langinline">quantity</span>
    element; the <span class="langinline">getQuantity</span> method goes a step
    further and converts the elements value to the most appropriate natural Java
    type before returning it. (XMLBeans also provides a means for validating the
    XML as you work with it.)</p>
  <p>If you know a bit about XML schema, XMLBeans types should seem fairly intuitive.
    If you don't, you'll learn a lot by experimenting with XMLBeans using your
    own schemas and XML instances based on them. </p>
  <p>For more information on the methods of types generated from schema, see <a href="conMethodsForGeneratedJavaTypes.html">Methods
    for Types Generated From Schema</a>. For more about the how XMLBeans represents
    built-in schema types, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans
    Support for Built-In Schema Types</a>.</p>
  <h1>Using XQuery Expressions</h1>
  <p>With XMLBeans you can use XQuery to query XML for specific pieces of data.
    XQuery is sometimes referred to as &quot;SQL for XML&quot; because it provides
    a mechanism to access data directly from XML documents, much as SQL provides
    a mechanism for accessing data in traditional databases.</p>
  <p>XQuery borrows some of its syntax from XPath, a syntax for specifying nested
    data in XML. The following example returns all of the <span class="langinline">line-item</span>
    elements whose <span class="langinline">price</span> child elements have values
    less than or equal to 20.00:</p>
  <pre>
PurchaseOrderDocument doc = PurchaseOrderDocument.Factory.parse(po);

/*
 * The XQuery expression is the following two strings combined. They're
 * declared separately here for convenience. The first string declares
 * the namespace prefix that's used in the query expression; the second
 * declares the expression itself.
 */
String nsText = "declare namespace po = 'http://openuri.org/easypo'";
String pathText = "$this/po:purchase-order/po:line-item[po:price <= 20.00]";
String queryText = nsText + pathText;

XmlCursor itemCursor = doc.newCursor().execQuery(queryText);
System.out.println(itemCursor.xmlText());
</pre>
  <p>This code creates a new cursor at the start of the document. From there,
    it uses the <span class="langinline">XmlCursor</span> interface's <span class="langinline">execQuery</span>
    method to execute the query expression. In this example, the method's parameter
    is an XQuery expression that simply says, &quot;From my current location,
    navigate through the <span class="langinline">purchase-order</span> element
    and retrieve those <span class="langinline">line-item</span> elements whose
    value is less than or equal to 20.00.&quot; The <span class="langinline">$this</span>
    variable means &quot;the current position.&quot;</p>
  <p>For more information about XQuery, see <a href="http://www.w3.org/TR/xquery/" target="_blank">XQuery
    1.0: An XML Query Language</a> at the W3C web site.</p>
  <h2>Using XML Cursors</h2>
  <p>In the preceding example you may have noticed the <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlCursor.html">XmlCursor</a></span>
    interface. In addition to providing a way to execute XQuery expression, an
    XML cursors offers a fine-grained model for manipulating data. The XML cursor
    API, analogous to the DOM's object API, is simply a way to point at a particular
    piece of data. So, just like a cursor helps navigate through a word processing
    document, the XML cursor defines a location in XML where you can perform actions
    on the selected XML.</p>
  <p>Cursors are ideal for moving through an XML document when there's no schema
    available. Once you've got the cursor at the location you're interested in,
    you can perform a variety of operations with it. For example, you can set
    and get values, insert and remove fragments of XML, copy fragments of XML
    to other parts of the document, and make other fine-grained changes to the
    XML document.</p>
  <p>The following example uses an XML cursor to navigate to the <span class="langinline">customer</span>
    element's <span class="langinline">name</span> child element.</p>
  <pre>
PurchaseOrderDocument doc =
    PurchaseOrderDocument.Factory.parse(po);

XmlCursor cursor = doc.newCursor();
cursor.toFirstContentToken();
cursor.toFirstChildElement();
cursor.toFirstChildElement();
System.out.println(cursor.getText());

cursor.dispose();
</pre>
  <p>What's happening here? As with the earlier example, the code loads the XML
    from a <span class="langinline">File</span> object. After loading the document,
    the code creates a cursor at its beginning. Moving the cursor a few times
    takes it to the nested <span class="langinline">name </span> element. Once
    there, the getText method retrieves the element's value.</p>
  <p>This is just an introduction to XML cursors. For more information about using
    cursors, see <a href="conNavigatingXMLwithCursors.html">Navigating XML with
    Cursors</a>.</p>
  <h2>Where to Go Next</h2>
</div>
<ul>
  <li>
    <div>XMLBeans provides intuitive ways to handle XML, particularly if you're
      starting with schema. If you're accessing XML that's based on a schema,
      you'll probably find it most efficient to access the XML through generated
      types specific to the schema. To do this, you begin by compiling the schema
      to generate interfaces. For more information on using XMLBeans types generated
      by compiling schema, see <a href="conJavaTypesGeneratedFromUserDerived.html">Java
      Types Generated From User-Derived Schema Types</a> and <a href="conMethodsForGeneratedJavaTypes.html">Methods
      for Types Generated From Schema</a>.</div>
  </li>
  <li>
    <div>You might be interested in reading more about the type system on which
      XMLBeans is based, particularly if you're using types generated from schema.
      XMLBeans provides a hierarchical system of types that mirror what you find
      in the XML schema specification itself. If you're working with schema, you
      might find it helps to understand how these types work. For more information,
      see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support
      for Built-In Schema Types</a> and <a href="conIntroToTheSchemaTypeSystem.html">Introduction
      to Schema Type Signatures</a>.</div>
  </li>
  <li>
    <div>XMLBeans provides access to XML through XQuery, which borrows path syntax
      from XPath. With XQuery, you can specify specific fragments of XML data
      with or without schema. To learn more about using XQuery and XPath in XMLBeans,
      see <a href="conSelectingXMLwithXQueryPathXPath.html">Selecting XML with
      XQuery and XPath</a>.</div>
  </li>
  <li>You can use the <span class="langinline">XmlCursor</span> interface for
    fine-grained navigation and manipulation of XML. For more information, see
    <a href="conNavigatingXMLwithCursors.html">Navigating XML with Cursors</a>.</li>
</ul>
<div>
  <p class="notepara"><strong>Note:</strong> The xbean.jar file that contains
    the XMLBeans library is fully functional as a standalone library.</p>
  <h1>Related Topics</h1>
  <p><a href="../../samples/navXMLBeansSamples.html">XMLBeans Samples</a></p>
</div>
<!-- InstanceEndEditable -->
<script language="JavaScript">

</script>
</body>
</html>