This package provides a way to invoke XJC from within another program. The primarily target of this API is the JAX-WS RI, but we hope that this API would be useful for other integration purposes as well.

Getting Started: Using XJC

To invoke XJC, a typical client would do something like this:

    SchemaCompiler sc = XJC.createSchemaCompiler();
    sc.parseSchema(new InputSource(schema1Url.toExternalForm()));
    sc.parseSchema(new InputSource(schema2Url.toExternalForm()));
    ...
    S2JModel model = sc.bind();

The bind operation causes XJC to do the bulk of the work, such as figuring out what classes to generate, what methods/fields to generate, etc. The obtained model contains useful introspective information about how the binding was performed (such as relationship between XML types and generated Java classes)

Once the model is obtained, generate the code into the file system as follows:

    JCodeModel cm = model.generateCode( null, ... );
    cm.build(new FileCodeWriter(outputDir));

Implementation Note

This package shouldn't contain any implementation code.

Code Generator

FieldRenderer and its implementation classes. Unless you are deriving from these classes to define your own custom renderer, you shouldn't be using these classes directly. Use the outline package.

This model is the recipes for the code generation. It captures the essence of the JAXB-bound beans, so that the actual Java code can be generated from this object model mechanically without knowing anything about how the model was built.

Most of the classes/interfaces in this package has one-to-one relationship with the parameterized core model in the com.sun.xml.bind.v2.model.core package. Refer to the core model for better documentation.

The model for XJC also exposes a few additional information on top of the core model. Those are defined in this package.

Compile-time representation of Java type system.

These classes are used as TypeT and ClassDeclT of the model parameterization. This implementaion is designed to be capable of representing pre-existing classes (such as java.lang.String) as well as the generated classes (represented as JDefinedClass.)

Handling of Primitive Types

Primitive types have two forms (int and Integer), and this complicates the binding process. For this reason, inside the front end, we always use the boxed types. We'll use the unboxed form only in the back end when we know the field doesn't need to represent the null value.

Code generation phase builds an outline little by little, while each step is using the outline built by the prior steps.

Front-end that reads schema(s) and produce BGM.

Object Model that represents DTD binding information.

internalization of external binding files and <jaxb:bindings> customizations.

RelaxNGCC is used to parse XML syntax into this representation, and the other parts of XJC will use this object model.

scan DTD stream and generates appropriate events.