Generate XStream Classes

While dealing with XStream if you had to create mapper classes and write a parser you would want use a shortcut for solution.

For the next time i will follow the below path

1) Create xsd file for the given xml using IntelliJ Idea

2) Create Jaxb  classes for the generated xsd file : http://goo.gl/uOjSAz

3) in the generated you need to put add : @XStreamAlias( "xml_tag_name_for_classs" ) for each class or attribute when you see the @XmlRootElement(name = "xml_tag_name_for_the _item_or_class")
 this will remove all undefined field exceptions of the XStream
If you get duplicate field exception add the @XStreamImplicit for the related field in the class
(I use copy paste for this job and if you have selected the third item in the first step you will have only one java file and replacing annotations will be easier. I have tried the other 2 options too for you)

4) in the parser class you need to xstream.processAnnotations(Your_class_name.class); Otherwise XStream will not recognize your annotations..Somethings are stupid still waits commands to do its work :/


In the end Parser class will be something like below

public class DataSharingParser {

    public static void main(String[] args) {
        try {
            XStream xstream = new XStream(new DomDriver());
            //xstream.autodetectAnnotations(true);

            xstream.processAnnotations(Root.class);
            xstream.processAnnotations(Root.Data.class);
            xstream.processAnnotations(Root.Error.class);
            xstream.processAnnotations(Root.Header.class);
            xstream.processAnnotations(Root.Data.CustomerDataShareOptionList.class);
            xstream.processAnnotations(Root.Data.CustomerDataShareOptionList.SharingPercentageList.class);
            xstream.processAnnotations(Root.Data.CustomerDataShareOptionList.DataShareOptionList.class);
            xstream.processAnnotations(Root.Data.CustomerDataShareOptionList.DataShareOptionList.SubscriptionList.class);
            xstream.processAnnotations(Root.Error.MsgList.class);
            xstream.processAnnotations(Root.Error.MsgList.Msg.class);
            xstream.processAnnotations(Root.Error.MsgList.Msg.Valuelist.class);

            Path  xmlPath = Paths.get("C:\\somewhere_in_there\\src", "your_lovely.xml");
            byte[] wikiArray = Files.readAllBytes(xmlPath);
            String asString = new String(wikiArray, "UTF-8");
            Root root = (Root) xstream.fromXML(asString);

            Root.Data data = root.getData();

...more parsing sources goes below...

        } catch (IOException e) {
            System.out.println(e);
        }

        System.exit(0);

    }
}

Note: You may not trust the xstream.autodetectAnnotations(true); while using XStream-1.4.7 and java 1.7

Lets do some XStream test

Aim: Keep a finite state machine configuration in a xml file.

A sample synthetic scenario for this ;
    Get messageBoxes of the users. Put the messageBoxes into a blockingQueue , let some threads process the mailboxes and get new and old messeges from the boxes and seperate them to different queues .
    Then process new messages (exm:delete if it is keeped longer than expected) and put some data for notification sms to the owner of expired message.Some threads will process this queue and will send smses and they will put some data to the edr queue.
    If the message is old (read message) threads on the oldMessageQueue put data to the edr queue directly without sending sms.

Maybe we want to use this states and conditions in a state manager base implementation/code generator which is not written yet ;)

public class StateList {
    public StateList () {
    }

    public List getFsm () {
        return fsm;
    }

    public void setFsm (List fsm) {
        this.fsm = fsm;
    }

    private Listfsm = new ArrayList();
}

public class State {
    public State () {
    }

    private String queueName;
    private int threadCount;
    private int queueSize;
    private String executorClassName;
    private List transitions = new java.util.ArrayList();

    public String getExecutorClassName () {
        return executorClassName;
    }

    public String getQueueName () {
        return queueName;
    }

    public int getThreadCount () {
        return threadCount;
    }

    public int getQueueSize () {
        return queueSize;
    }

    public List getTransitions () {
        return transitions;
    }

    public void setExecutorClassName (String executorClassName) {
        this.executorClassName = executorClassName;
    }

    public void setQueueName (String queueName) {
        this.queueName = queueName;
    }

    public void setThreadCount (int threadCount) {
        this.threadCount = threadCount;
    }

    public void setQueueSize (int queueSize) {
        this.queueSize = queueSize;
    }

    public void setTransitions (List transitions) {
        this.transitions = transitions;
    }
}

public class Transition {
    public Transition () {
    }

    public String getCondition () {
        return condition;
    }

    public String getName () {
        return name;
    }

    public void setCondition (String condition) {
        this.condition = condition;
    }

    public void setName (String name) {
        this.name = name;
    }

    private String name ;
    private String condition;
}

package XstreamTester;

import java.util.*;
import com.thoughtworks.xstream.*;
import java.io.*;

public class XStreamTester {
    public XStreamTester () {
     /* messageboxGetter->//newMsgProcessor ->SmsSender->EdrWrite
                                       ->//oldMsgProcessor ->EdrWrite
     */
    }

    public static void main (String[] args) {
        XStreamTester xstreamtester = new XStreamTester ();

        XStream stateConfiguration = new XStream ();
        stateConfiguration.alias ("state", State.class);
        stateConfiguration.alias ("transition", Transition.class);
        stateConfiguration.alias ("states", StateList.class);

        StateList stateConfig = new StateList();
        List stateList = new ArrayList();
        // messagebox state
        State mboxState = new State ();
        mboxState.setExecutorClassName ("MboxGetter");

        List mboxTransitions = new ArrayList();
        Transition newMessageTransition = new Transition ();
        newMessageTransition.setName ("newMessageQueue");
        newMessageTransition.setCondition ("new");
        mboxTransitions.add (newMessageTransition);
        Transition oldMessageTransition = new Transition ();
        oldMessageTransition.setName ("oldMessageQueue");
        oldMessageTransition.setCondition ("old");
        mboxTransitions.add (oldMessageTransition);
        mboxState.setTransitions (mboxTransitions);

        mboxState.setQueueName ("messageBoxQueue");
        mboxState.setThreadCount (10);
        mboxState.setQueueSize (1000);
        stateList.add (mboxState);


        // new message state
        State newMsgState = new State ();
        newMsgState.setExecutorClassName ("newMessageProcessor");

        List newMsgTransitionList = new ArrayList();
        Transition smsTransition = new Transition ();
        smsTransition.setName ("smsQueue");
        smsTransition.setCondition ("deleted");
        newMsgTransitionList.add (smsTransition);
        newMsgState.setTransitions(newMsgTransitionList);

        newMsgState.setQueueName ("newMessageQueue");
        newMsgState.setThreadCount (10);
        newMsgState.setQueueSize (1000);
        stateList.add (newMsgState);

        // old message state
        State oldMsgState = new State ();
        oldMsgState.setExecutorClassName ("oldMessageProcessor");

        List oldMsgTransitionList = new ArrayList();
        Transition edrTransition = new Transition ();
        edrTransition.setName ("edrQueue");
        edrTransition.setCondition ("deleted");
        oldMsgTransitionList.add (edrTransition);
        oldMsgState.setTransitions(oldMsgTransitionList);

        oldMsgState.setQueueName ("oldMessageQueue");
        oldMsgState.setThreadCount (10);
        oldMsgState.setQueueSize (1000);
        stateList.add (oldMsgState);


        //sms state
        State smsState = new State ();
        smsState.setExecutorClassName ("smsQueueProcessor");

        List smsTransitionList = new ArrayList();
        Transition sms2EdrTransition = new Transition ();
        sms2EdrTransition.setName ("edr");
        sms2EdrTransition.setCondition ("smsSent");
        smsTransitionList.add (sms2EdrTransition);

        smsState.setTransitions(smsTransitionList);
        smsState.setQueueName ("smsQueue");
        smsState.setThreadCount (10);
        smsState.setQueueSize (1000);
        stateList.add (smsState);


        //edr state
        State edrState = new State ();
        smsState.setExecutorClassName ("edrQueueProcessor");

        edrState.setQueueName ("edrQueue");
        edrState.setThreadCount (10);
        edrState.setQueueSize (1000);
        stateList.add (edrState);


        stateConfig.setFsm(stateList);
        String xml = stateConfiguration.toXML (stateConfig);
        try {
            BufferedWriter out = new BufferedWriter (new FileWriter (
                "/home/serkans/jbproject/UM_Test/xml/stateConfiguration.xml"));
            out.write (xml);
            out.close ();
        } catch (IOException e) {
            e.printStackTrace ();
        }
        System.exit (0);
    }
}

Generated xml will be something like this.
<states>
  <fsm>
    <state>
      <queueName>messageBoxQueue</queueName>
      <threadCount>10</threadCount>
      <queueSize>1000</queueSize>
      <executorClassName>MboxGetter</executorClassName>
      <transitions>
        <transition>
          <name>newMessage</name>
          <condition>new</condition>
        </transition>
        <transition>
          <name>oldMessage</name>
          <condition>old</condition>
        </transition>
      </transitions>
    </state>
    <state>
      <queueName>newMessageQueue</queueName>
      <threadCount>10</threadCount>
      <queueSize>1000</queueSize>
      <executorClassName>newMessageProcessor</executorClassName>
      <transitions>
        <transition>
          <name>sms</name>
          <condition>deleted</condition>
        </transition>
      </transitions>
    </state>
    <state>
      <queueName>oldMessageQueue</queueName>
      <threadCount>10</threadCount>
      <queueSize>1000</queueSize>
      <executorClassName>oldMessageProcessor</executorClassName>
      <transitions>
        <transition>
          <name>edr</name>
          <condition>deleted</condition>
        </transition>
      </transitions>
    </state>
    <state>
      <queueName>smsQueue</queueName>
      <threadCount>10</threadCount>
      <queueSize>1000</queueSize>
      <executorClassName>edrQueueProcessor</executorClassName>
      <transitions>
        <transition>
          <name>edr</name>
          <condition>smsSent</condition>
        </transition>
      </transitions>
    </state>
    <state>
      <queueName>edrQueue</queueName>
      <threadCount>10</threadCount>
      <queueSize>1000</queueSize>
      <transitions/>
    </state>
  </fsm>
</states>