Chapter 4. Consuming Input Data

• By default, Smooks reads XML data. To set features on the default XML reader, omit the class name from the configuration:

  <reader>
      <features>
          <setOn feature="http://a" />
          <setOn feature="http://b" />
          <setOff feature="http://c" />
          <setOff feature="http://d" />
      </features>
  </reader>
  

1. Use the http://www.milyn.org/xsd/smooks/csv-1.2.xsd configuration namespace to configure the reader.
   Here is a basic configuration:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd">
    
       <!--
       Configure the CSV to parse the message into a stream of SAX events.
       -->
       <csv:reader fields="firstname,lastname,gender,age,country" separator="|" quote="'" skipLines="1" />
    
   </smooks-resource-list>
   

2. You will see the following event stream:

   <csv-set>
       <csv-record>
           <firstname>Tom</firstname>
           <lastname>Fennelly</lastname>
           <gender>Male</gender>
           <age>21</age>
           <country>Ireland</country>
       </csv-record>
       <csv-record>
           <firstname>Tom</firstname>
           <lastname>Fennelly</lastname>
           <gender>Male</gender>
           <age>21</age>
           <country>Ireland</country>
       </csv-record>
   </csv-set>
   

1. To define fields in XML configurations you must use a comma-separated list of names in the fields attribute.
2. Make sure the field names follow the same naming rules as XML element names:
3. • they can contain letters, numbers, and other characters
   • they cannot start with a number or punctuation character
   • they cannot start with the letters xml (or XML or Xml, etc)
   • they cannot contain spaces
4. Set the rootElementName and recordElementName attributes so you can modify the csv-set and csv-record element names. The same rules apply for these names.
5. You can define string manipulation functions on a per-field basis. These functions are executed before the data is converted into SAX events. Define them after the field name, separating the two with a question mark:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd">
    
       <csv:reader fields="lastname?trim.capitalize,country?upper_case" />
    
   </smooks-resource-list>
   
   

6. To get Smooks to ignore fields in a CSV record, you must specify the $ignore$ token as the field's configuration value. Specify the number of fields to be ignored simply by following the $ignore$ token with a number (so use $ignore$3 to ignore the next three fields.) Use $ignore$+ to ignore all of the fields to the end of the CSV record.

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd">
    
       <csv:reader fields="firstname,$ignore$2,age,$ignore$+" />
    
   </smooks-resource-list>
   
   

1. Read the following to learn how to CSV records to Java objects. In this example, we will use CSV records for people:

   Tom,Fennelly,Male,4,Ireland
   Mike,Fennelly,Male,2,Ireland
   

2. Input this code to bind the record to a person:

   
   public class Person {
       private String firstname;
       private String lastname;
       private String country;
       private Gender gender;
       private int age;
   }
    
   public enum Gender {
       Male, 
       Female;
   }
   
   

3. Input the following code and modify it to suit your task:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd">
    
       <csv:reader fields="firstname,lastname,gender,age,country">
           <!-- Note how the field names match the property names on the Person class. -->
           <csv:listBinding beanId="people" class="org.milyn.csv.Person" />
       </csv:reader>
    
   </smooks-resource-list>
   

4. To execute the configuration, use this code:

   
   Smooks smooks = new Smooks(configStream);
   JavaResult result = new JavaResult();
    
   smooks.filterSource(new StreamSource(csvStream), result);
    
   List<Person> people = (List<Person>) result.getBean("people");
   

5. You can create Maps from the CSV record set:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd">
    
       <csv:reader fields="firstname,lastname,gender,age,country">
           <csv:mapBinding beanId="people" class="org.milyn.csv.Person" keyField="firstname" />
       </csv:reader>
    
   </smooks-resource-list>
   
   

6. The configuration above produces a map of person instances, keyed to the firstname value of each person. This is how it is executed:

   
   Smooks smooks = new Smooks(configStream);
   JavaResult result = new JavaResult();
    
   smooks.filterSource(new StreamSource(csvStream), result);
    
   Map<String, Person> people = (Map<String, Person>) result.getBean("people");
    
   Person tom = people.get("Tom");
   Person mike = people.get("Mike");
   
   

   Virtual models are also supported, so you can define the class attribute as a java.util.Map and bind the CSV field values to map instances which are, in turn, added to a list or map.

1. To configure a Smooks instance with a CSV reader to read a person record set, use the code below. It will bind the records to a list of person instances.

   
   Smooks smooks = new Smooks();
    
   smooks.setReaderConfig(new CSVReaderConfigurator("firstname,lastname,gender,age,country")
                     .setBinding(new CSVBinding("people", Person.class, CSVBindingType.LIST)));
    
   JavaResult result = new JavaResult();
   smooks.filterSource(new StreamSource(csvReader), result);
    
   List<Person> people = (List<Person>) result.getBean("people");
   
   

   Note

   You can also optionally configure the Java Bean. The Smooks instance could instead (or additionally) be configured programmatically to use other visitor implementations to process the CSV record set.
2. To bind the CSV's records to a list or map of a Java type that reflects the data in your CSV records, use the CSVListBinder or CSVMapBinder classes:

   
   // Note: The binder instance should be cached and reused...
   CSVListBinder binder = new CSVListBinder("firstname,lastname,gender,age,country", Person.class);
    
   List<Person> people = binder.bind(csvStream);
   
   CSVMapBinder:
   
   // Note: The binder instance should be cached and reused...
   CSVMapBinder binder = new CSVMapBinder("firstname,lastname,gender,age,country", Person.class, "firstname");
    
   Map<String, Person> people = binder.bind(csvStream);
   
   

   If you need more control over the binding process, revert back to using the lower-level APIs.

1. To configure the fixed-length reader, modify the http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd configuration namespace as shown below:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:fl="http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd">
    
       <!--
       Configure the Fixed length to parse the message into a stream of SAX events.
       -->
       <fl:reader fields="firstname[10],lastname[10],gender[1],age[2],country[2]" skipLines="1" />
    
   </smooks-resource-list>
   
   

   Here is an example input file:

   #HEADER
   Tom       Fennelly  M 21 IE
   Maurice  Zeijen     M 27 NL
   

   Here is the event stream that will be generated:

   
   <set>
       <record>
           <firstname>Tom       </firstname>
           <lastname>Fennelly  </lastname>
           <gender>M</gender>
           <age> 21</age>
           <country>IE</country>
       </record>
       <record>
           <firstname>Maurice  </firstname>
           <lastname>Zeijen     </lastname>
           <gender>M</gender>
           <age>27</age>
           <country>NL</country>
       </record>
   </set>
   ]]>
   

2. Define the string manipulation functions as shown below:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:fl="http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd">
    
       <!--
       Configure the fixed length reader to parse the message into a stream of SAX events.
       -->
       <fl:reader fields="firstname[10]?trim,lastname[10]trim.capitalize,gender[1],age[2],country[2]" skipLines="1" />
    
   </smooks-resource-list>
   
   

3. You can also ignore these fields if you choose:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:fl="http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd">
    
       <fl:reader fields="firstname,$ignore$[2],age,$ignore$[10]" />
    
   </smooks-resource-list>
   
   

1. To bind fixed-length records to a person, see the configuration below. In this example we will use these sample records:

   Tom       Fennelly  M 21 IE
   Maurice  Zeijen     M 27 NL
   

   This is how you bind them to a person:

   [
   public class Person {
       private String firstname;
       private String lastname;
       private String country;
       private String gender;
       private int age;
   }
   
   

2. Configure the records so they look like this:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"  xmlns:fl="http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd">
    
       <fl:reader fields="firstname[10]?trim,lastname[10]?trim,gender[1],age[3]?trim,country[2]">
           <!-- Note how the field names match the property names on the Person class. -->
           <fl:listBinding BeanId="people" class="org.milyn.fixedlength.Person" />
       </fl:reader>
    
   </smooks-resource-list>
   
   

3. Execute it as shown:

   Smooks smooks = new Smooks(configStream);
   JavaResult result = new JavaResult();
    
   smooks.filterSource(new StreamSource(fixedLengthStream), result);
    
   List<Person> people = (List<Person>) result.getBean("people");
   
   

4. Optionally, use this configuration to create maps from the fixed-length record set:

   
   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"  xmlns:fl="http://www.milyn.org/xsd/smooks/fixed-length-1.3.xsd">
    
       <fl:reader fields="firstname[10]?trim,lastname[10]?trim,gender[1],age[3]?trim,country[2]">
           <fl:mapBinding BeanId="people" class="org.milyn.fixedlength.Person" keyField="firstname" />
       </fl:reader>
   

5. This is how you execute the map of person instances that is produced:

   Smooks smooks = new Smooks(configStream);
   JavaResult result = new JavaResult();
    
   smooks.filterSource(new StreamSource(fixedLengthStream), result);
    
   Map<String, Person> people = (Map<String, Person>) result.getBean("people");
    
   Person tom = people.get("Tom");
   Person mike = people.get("Maurice");
   

   Virtual Models are also supported, so you can define the class attribute as a java.util.Map and bind the fixed-length field values to map instances, which are in turn added to a list or a map.

1. Use this code to configure the fixed-length reader to read a person record set, binding the record set into a list of person instances:

   Smooks smooks = new Smooks();
    
   smooks.setReaderConfig(new FixedLengthReaderConfigurator("firstname[10]?trim,lastname[10]?trim,gender[1],age[3]?trim,country[2]")
                     .setBinding(new FixedLengthBinding("people", Person.class, FixedLengthBindingType.LIST)));
    
   JavaResult result = new JavaResult();
   smooks.filterSource(new StreamSource(fixedLengthStream), result);
    
   List<Person> people = (List<Person>) result.getBean("people");
   

   Configuring the Java binding is not mandatory. You can instead programmatically configure the Smooks instance to use other visitor implementations to carry out various forms of processing on the fixed-length record set.
2. To bind fixed-length records directly to a list or map of a Java type that reflects the data in your fixed-length records, use either the FixedLengthListBinder or the FixedLengthMapBinder classes:

   // Note: The binder instance should be cached and reused...
   FixedLengthListBinder binder = new FixedLengthListBinder("firstname[10]?trim,lastname[10]?trim,gender[1],age[3]?trim,country[2]", Person.class);
    
   List<Person> people = binder.bind(fixedLengthStream);
   
   FixedLengthMapBinder:
   
   // Note: The binder instance should be cached and reused...
   FixedLengthMapBinder binder = new FixedLengthMapBinder("firstname[10]?trim,lastname[10]?trim,gender[1],age[3]?trim,country[2]", Person.class, "firstname");
    
   Map<String, Person> people = binder.bind(fixedLengthStream);
   

   If you need more control over the binding process, revert back to the lower level APIs.

1. To utilize EDI processing in Smooks, access the http://www.milyn.org/xsd/smooks/edi-1.2.xsd configuration namespace.
2. Modify this configuration to suit your needs:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:edi="http://www.milyn.org/xsd/smooks/edi-1.2.xsd">    
    <!--
       Configure the EDI Reader to parse the message stream into a stream of SAX events.
       -->
       <edi:reader mappingModel="edi-to-xml-order-mapping.xml" validate="false"/>
   </smooks-resource-list>
   

• Use the EDIReaderConfigurator to programmatically configure the Smooks instance to use the EDIReader as shown in the code below:

  Smooks smooks = new Smooks();
   
  // Create and initialise the Smooks config for the parser...
  smooks.setReaderConfig(new EDIReaderConfigurator("/edi/models/invoice.xml"));
   
  // Use the smooks as normal
  smooks.filterSource(....);
  

• To execute the Edifact Java Compiler through Maven, add the plug-in in your POM file:

  <build>
      <plugins>
          <plugin>
              <groupId>org.milyn</groupId>
              <artifactId>maven-ejc-plugin</artifactId>
              <version>1.2</version>
              <configuration>
                  <ediMappingFile>edi-model.xml</ediMappingFile>
                  <packageName>com.acme.order.model</packageName>
              </configuration>
              <executions>
                  <execution><goals><goal>generate</goal></goals></execution>
              </executions>
          </plugin>
      </plugins>
  </build>
  

• Create and execute the EJC task as shown below:

  <target name="ejc">
   
      <taskdef resource="org/milyn/ejc/ant/anttasks.properties">
          <classpath><fileset dir="/smooks-1.2/lib" includes="*.jar"/></classpath>
      </taskdef>
   
      <ejc edimappingmodel="src/main/resources/edi-model.xml"
           destdir="src/main/java"
           packagename="com.acme.order.model"/>
   
      <!-- Ant as usual from here on... compile and jar the source... -->
   
  </target>
  

• Set the http://www.milyn.org/xsd/smooks/unedifact-1.4.xsd namespace like this:

  <?xml version="1.0"?>
  <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:unedifact="http://www.milyn.org/xsd/smooks/unedifact-1.4.xsd">
   
      <unedifact:reader mappingModel="urn:org.milyn.edi.unedifact:d03b-mapping:v1.4" ignoreNewLines="true" />
   
  </smooks-resource-list>
  

  The mappingModel attribute defines an URN that refers to the mapping model ZIP set's Maven artifact, which is used by the reader.

1. To programmatically configure Smooks to consume a UN/EDIFACT interchange (via, for instance, an UNEdifactReaderConfigurator), use the code below:

   Smooks smooks = new Smooks();
    
   smooks.setReaderConfig(new UNEdifactReaderConfigurator("urn:org.milyn.edi.unedifact:d03b-mapping:v1.4"));
   

2. Insert the following on the containing application's classpath:
   • the requisite EDI mapping models
   • the Smooks EDI cartridge
3. There may be some Maven dependancies your configuration will require. See the example below:

   <dependency>
       <groupId>org.milyn</groupId>
       <artifactId>milyn-smooks-edi</artifactId>
       <version>1.4</version>
   </dependency>
    
   <!-- Required Mapping Models -->
   <dependency>
       <groupId>org.milyn.edi.unedifact</groupId>
       <artifactId>d93a-mapping</artifactId>
       <version>v1.4</version>
   </dependency>
   <dependency>
       <groupId>org.milyn.edi.unedifact</groupId>
       <artifactId>d03b-mapping</artifactId>
       <version>v1.4</version>
   </dependency>
   

4. Once an application has added an EDI mapping model ZIP set to its classpath, you can configure Smooks to use this model by simply referencing the Maven artifact using a URN as the unedifact:reader configuration's mappingModel attribute value:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:unedifact="http://www.milyn.org/xsd/smooks/unedifact-1.4.xsd"
    
       <unedifact:reader mappingModel="urn:org.milyn.edi.unedifact:d03b-mapping:v1.4" ignoreNewLines="true" />
    
   </smooks-resource-list>
   

1. To add the D93A mapping model ZIP set to your application classpath, set the following dependency to your application's POM file:

   <!-- The mapping model sip set for the D93A directory... -->
   <dependency>
       <groupId>org.milyn.edi.unedifact</groupId>
       <artifactId>d93a-mapping</artifactId>
       <version>v1.4</version>
   </dependency>
   

2. Configure Smooks to use this ZIP set by adding the unedifact:reader configuration to your Smooks configuration as shown below:

   <unedifact:reader mappingModel="urn:org.milyn.edi.unedifact:d93a-mapping:v1.4" />
   

   Note how you configure the reader using a URN derived from the Maven artifac's dependency information.
3. You can also add multiple mapping model ZIP sets to your application's classpath. To do so, add all of them to your unedifact:reader configuration by comma-separating the URNs.
4. Pre-generated Java binding model sets are provided with the tool (there is one per mapping model ZIP set). Use these to process UN/EDIFACT interchanges using a very simple, generated factory class.

1. To process a D03B UN/EDIFACT message interchange, follow the example below:

   
   Reading:
   
   // Create an instance of the EJC generated factory class... cache this and reuse !!!
   D03BInterchangeFactory factory = D03BInterchangeFactory.getInstance();
    
   // Deserialize the UN/EDIFACT interchange stream to Java...
   UNEdifactInterchange interchange = factory.fromUNEdifact(ediInStream);
    
   // Need to test which interchange syntax version.  Supports v4.1 at the moment...
   if(interchange instanceof UNEdifactInterchange41) {
       UNEdifactInterchange41 interchange41 = (UNEdifactInterchange41) interchange;
    
       for(UNEdifactMessage41 message : interchange41.getMessages()) {
           // Process the messages...
    
           Object messageObj = message.getMessage();
    
           if(messageObj instanceof Invoic) {
               // It's an INVOIC message....
               Invoic invoic = (Invoic) messageObj;
               ItemDescription itemDescription = invoic.getItemDescription();
               // etc etc....
           } else if(messageObj instanceof Cuscar) {
               // It's a CUSCAR message...
           } else if(etc etc etc...) {
               // etc etc etc...
           }
       }
   }
   
   
   Writing:
   
   factory.toUNEdifact(interchange, ediOutStream);
   
   

2. Use Maven to add the ability to process a D03B message interchange by adding the binding dependency for that directory (you can also use pre-generated UN/EDIFACT Java object models distributed via the MavenSNAPSHOT and Central repositories):

   <dependency>
       <groupId>org.milyn.edi.unedifact</groupId>
       <artifactId>d03b-binding</artifactId>
       <version>v1.4</version>
   </dependency>
   

1. To process JSON data, you must configure a JSON reader:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:json="http://www.milyn.org/xsd/smooks/json-1.1.xsd">
    
       <json:reader/>
    
   </smooks-resource-list>
   

2. Set the XML names of the root, document and array elements by using the following configuration options:
   • rootName: this is the name of the root element. The default is yaml.
   • elementName: this is the name of a sequence element. The default is element.
3. You may wish to use characters in the key name that are not allowed in the XML element name. The reader offers multiple solutions to this problem. It can search and replace white spaces, illegal characters and the number in key names that start with a number. You can also use it to replace one key name with a completely different one. The following sample code shows you how to do this:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:json="http://www.milyn.org/xsd/smooks/json-1.1.xsd">
    
       <json:reader keyWhitspaceReplacement="_" keyPrefixOnNumeric="n" illegalElementNameCharReplacement=".">
           <json:keyMap>
               <json:key from="some key">someKey</json:key>
               <json:key from="some&key" to="someAndKey" />
           </json:keyMap>
       </json:reader>
    
   </smooks-resource-list>
   

   • keyWhitspaceReplacement: this is the replacement character for white spaces in a JSON map key. By default this is not defined, so the reader does not automatically search for white spaces.
   • keyPrefixOnNumeric: this is the prefix character to add if the JSON node name starts with a number. By default, this is not defined, so the reader does not search for element names that start with a number.
   • illegalElementNameCharReplacement: if illegal characters are encountered in a JSON element name then they are replaced with this value.
4. You can also configure these optional settings:
5. • nullValueReplacement: this is the replacement string for JSON null values. The default is an empty string.
   • encoding: this is the default encoding of any JSON message InputStream processed by the reader. The default encoding is UTF-8.

     Note

     This feature is deprecated. Instead, you should now manage the JSON streamsource character encoding by supplying a java.io.Reader to the Smooks.filterSource() method.
6. To configure Smooks programmatically to read a JSON configuration, use the JSONReaderConfiguratorclass:

   Smooks smooks = new Smooks();
    
   smooks.setReaderConfig(new JSONReaderConfigurator()
           .setRootName("root")
           .setArrayElementName("e"));
    
   // Use Smooks as normal...
   

Procedure 4.1. Task

1. Configure your reader to process YAML files as shown:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:yaml="http://www.milyn.org/xsd/smooks/yaml-1.4.xsd">
    
       <yaml:reader/>
    
   </smooks-resource-list>
   

2. Configure the YAML stream to contain multiple documents. The reader handles this by adding a document element as a child of the root element. An XML-serialized YAML stream with one empty YAML document looks like this:

   <yaml>
       <document>
       </document>
   </yaml>
   

3. Configure Smooks programmatically to read a YAML configuration by exploiting the YamlReaderConfigurator class:

   Smooks smooks = new Smooks();
    
   smooks.setReaderConfig(new YamlReaderConfigurator()
           .setRootName("root")
           .setDocumentName("doc")
           .setArrayElementName("e"))
           .setAliasStrategy(AliasStrategy.REFER_RESOLVE)
           .setAnchorAttributeName("anchor")
           .setAliasAttributeName("alias");
    
   // Use Smooks as normal...
   

• You can use characters in the key name that are not allowed in the XML element name. The reader offers multiple solutions to this problem. It can search and replace white spaces, illegal characters and the number in key names that start with a number. You can configure it to replace one key name with a completely different one, as shown below:

  <?xml version="1.0"?>
  <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:yaml="http://www.milyn.org/xsd/smooks/yaml-1.4.xsd">
   
      <yaml:reader keyWhitspaceReplacement="_" keyPrefixOnNumeric="n" illegalElementNameCharReplacement=".">
          <yaml:keyMap>
              <yaml:key from="some key">someKey</yaml:key>
              <yaml:key from="some&key" to="someAndKey" />
          </yaml:keyMap>
      </yaml:reader>
   
  </smooks-resource-list>
  

1. Smooks can transform one Java object graph into another. To do this, it uses the SAX processing model, which means no intermediate object model is constructed. Instead, the source Java object graph is turned directly into a stream of SAX events, which are used to populate the target Java object graph.
   If you use the HTML Smooks Report Generator tool, you will see that the event stream produced by the source object model is as follows:

   <example.srcmodel.Order>
       <header>
           <customerNumber>
               </customerNumber>
              <customerName>
          </customerName>;
       </header>
       <orderItems>
           <example.srcmodel.OrderItem>
               <productId>
              </productId>
               <quantity>
               >/quantity>
               <price>
               </price>
           </example.srcmodel.OrderItem>
       </orderItems>
   </example.srcmodel.Order>
   

2. Aim the Smooks Java bean resources at this event stream. The Smooks configuration for performing this transformation (smooks-config.xml) is as follows:

   <?xml version="1.0"?>
   <smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:jb="http://www.milyn.org/xsd/smooks/javabean-1.4.xsd">
    
       <jb:bean BeanId="lineOrder" class="example.trgmodel.LineOrder" createOnElement="example.srcmodel.Order">
           <jb:wiring property="lineItems" BeanIdRef="lineItems" />
           <jb:value property="customerId" data="header/customerNumber" />
           <jb:value property="customerName" data="header/customerName" />
       </jb:bean<
    
       <jb:bean BeanId="lineItems" class="example.trgmodel.LineItem[]" createOnElement="orderItems">
           <jb:wiring BeanIdRef="lineItem" />
       </jb:bean>
    
    
       <jb:bean BeanId="lineItem" class="example.trgmodel.LineItem" createOnElement="example.srcmodel.OrderItem">
           <jb:value property="productCode" data="example.srcmodel.OrderItem/productId" />
           <jb:value property="unitQuantity" data="example.srcmodel.OrderItem/quantity" />
           <jb:value property="unitPrice" data="example.srcmodel.OrderItem/price" />
       </jb:bean>
    
   </smooks-resource-list>
   

3. The source object model is provided to Smooks via a org.milyn.delivery.JavaSource object. Create this object by passing the constructor the source model's root object. The resulting Java Source object is used in the Smooks#filter method. Here is the resulting code:

   protected LineOrder runSmooksTransform(Order srcOrder) throws IOException, SAXException {
       Smooks smooks = new Smooks("smooks-config.xml");
       ExecutionContext executionContext = smooks.createExecutionContext();
    
       // Transform the source Order to the target LineOrder via a
       // JavaSource and JavaResult instance...
       JavaSource source = new JavaSource(srcOrder);
       JavaResult result = new JavaResult();
    
       // Configure the execution context to generate a report...
       executionContext.setEventListener(new HtmlReportGenerator("target/report/report.html"));
    
       smooks.filterSource(executionContext, source, result);
    
       return (LineOrder) result.getBean("lineOrder");
   }