Serialization of an object
I need to serialize an object for part of an assignment for school.
The object is of type: "Race" which has properties that are of type
int, String, and other objects(classes) that I created. When I
Serialize I get an XML file with the 'simple' properties, ints and
Strings, but my objects don't end up in the XML. There are no errors,
it just isn't there.
I'm not sure I want to post all the code here, there's multiple
layers, but I will post what I think you need to see.
Here is the XML output I get right now
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.6.0" class="java.beans.XMLDecoder">
<object class="Race">
<void property="raceDescriptionLong">
<string>Elven characters make great rangers. They tend not to make
good Paladins due to their chaotic tendencise</string>
</void>
<void property="raceDescriptionShort">
<string>A slim built humanoid. Highly dextrous and long lived</
string>
</void>
<void property="raceID">
<int>1</int>
</void>
<void property="raceName">
<string>Elf</string>
</void>
<void property="raceSource">
<string>PH 124</string>
</void>
</object>
</java>
here is the Race class, you will see that I have objects of types
AbilityModifiers (which manages a 0 - many group of class ability
modifier. I have added AbilityModifier objects to the
AbilitityModifiers object in testing my Race class.) I also have
Languages (Not implemented at this point) and Feats (also not
implemented, and I plan to remove them because they are in the wrong
class).
/**
*Race
*
*Author: Joseph (Sandy) Murdock
*
*Changes: Mar 31, 2007
*
*********************************************************************************************************/
import java.beans.XMLEncoder;
import java.beans.XMLDecoder;
import java.util.Vector;
public class Race
{
private int raceID;
private String raceName = "";
private String raceDescriptionShort = "";
private String raceDescriptionLong = "";
private String raceSource = "";
//private Vector v;
//AbilityModifiers are stored in a vector, using the AbilityModifiers
class
protected AbilityModifiers abilityModifiers;
//RacialFeats find how to declare vectors.
protected Feats feats;
//Languages vector
protected Languages languages;
public Race()
{
raceID = -1;
raceName = "";
raceDescriptionShort = "";
raceDescriptionLong = "";
raceSource = "";
abilityModifiers = new AbilityModifiers();
feats = new Feats();
languages = new Languages();
//v.add("test");
}
public Race(AbilityModifiers ab, Feats f, Languages l)
{
raceID = -1;
raceName = "";
raceDescriptionShort = "";
raceDescriptionLong = "";
raceSource = "";
abilityModifiers = ab;
feats = f;
languages = l;
}
/* Trying to get this to work!*/
public void setAbilityModifiers(AbilityModifiers am)
{
abilityModifiers = am;
}
public AbilityModifiers getAbilityModifiers()
{
return abilityModifiers;
}
/*------------------------------------*/
public void setRaceID(int RID)
{
raceID = RID;
}
public int getRaceID()
{
return raceID;
}
public void setRaceName(String RN)
{
raceName = new String(RN);
}
public String getRaceName()
{
return raceName;
}
public void setRaceDescriptionShort(String RD)
{
raceDescriptionShort = new String(RD);
}
public String getRaceDescriptionShort()
{
return raceDescriptionShort;
}
public void setRaceDescriptionLong(String RD)
{
raceDescriptionLong = new String(RD);
}
public String getRaceDescriptionLong()
{
return raceDescriptionLong;
}
public void setRaceSource(String rSource)
{
raceSource = new String(rSource);
}
public String getRaceSource()
{
return raceSource;
}
public void setStrModifier(int Str)
{
//Check to see if a strength modifier exists already is so, modify
it otherwise make a new one
abilityModifiers.addModifier(1, Str, "Race: " + raceName);
}
public int getStrModifierAmount(int instance)
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(Ability.STRENGTH, instance);
return AM.getValue();
}
public AbilityModifier getStrModifier(int instance)
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(Ability.STRENGTH, instance);
return AM;
}
public AbilityModifier getModifier(int instance, int type)
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(type, instance);
return AM;
}
public void setDexModifier(int dex)
{
//Check to see if a dex modifier exists already is so, modify it
otherwise make a new one
abilityModifiers.addModifier(2, dex, "Race: " + raceName);
}
public int getDexModifierAmount()
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(2, 1);
return AM.getValue();
}
public void setConModifier(int con)
{
abilityModifiers.addModifier(3, con, "Race: " + raceName);
}
public int getConModifierAmount()
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(3, 1);
return AM.getValue();
}
public void setIntModifier(int Int)
{
abilityModifiers.addModifier(4, Int, "Race: " + raceName);
}
public int getIntModifierAmount()
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(4, 1);
return AM.getValue();
}
public void setWisModifier(int wis)
{
abilityModifiers.addModifier(5, wis, "Race: " + raceName);
}
public int getWisModifierAmount()
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(5, 1);
return AM.getValue();
}
public void setChaModifier(int cha)
{
abilityModifiers.addModifier(6, cha, "Race: " + raceName);
}
public int getChaModifierAmount()
{
AbilityModifier AM = new AbilityModifier();
AM = abilityModifiers.getModifierByType(6, 1);
return AM.getValue();
}
public void getStrModifiers()
{
}
/**
* addFeat
*
*Inputs: Feat
*Output: String
*
*Used to insert a new Feat into the raceFeats vector. Returns a
string value:
* Success - it worked.
* Duplicate - it's already there.
*/
public String addFeat(Feat f)
{
boolean result;
result = feats.addFeat(f);
if(result = true)
{
return "Success";
}
else
{
return "Duplicate";
}
}
}
*****************************
my Ability Modifiers class (Yeah, I know it uses vectors but I have a
deadline for the assignment and I didn't know about arraylist at the
time I started).
*****************************
/**
* AbilityModifiers
*
*This class is intended to 'manage' ability modifiers.
*
*Since many other classes can have ability modifiers (from 0 - 6 of
them) this class will create
*a vector of ability modifier objects. Initially the vector will have
0 elements.
**/
import java.util.Vector;
import java.io.Serializable;
import java.io.*;
import java.beans.XMLEncoder;
import java.beans.XMLDecoder;
public class AbilityModifiers
{
int current;
private Vector<AbilityModifier> abilityModifiers; //vecter of ability
modifiers
public AbilityModifiers()
{
current = -1;
abilityModifiers = new Vector();
}
public AbilityModifiers(Vector v)
{
current = -1;
abilityModifiers = v;
}
public void setAbilityModifiers(Vector<AbilityModifier> am)
{
abilityModifiers = am;
}
public Vector<AbilityModifier> getAbilityModifiersV()
{
return abilityModifiers;
}
// return the number of ability modifiers
public int getNumModifiers()
{
return abilityModifiers.size();
}
/*
* addModifier
*
* inputs: AbilityModifier
* output: boolean
*
* Will add a new unique AbilityModifier to the vector and return
true. Otherwise returns false.
*/
public boolean addModifier(AbilityModifier am)
{
boolean unique = isUnique(am);
if(unique == true)
{
abilityModifiers.addElement(am);
return true;
}
else
{
return false;
}
}
/*
* addModifier
*
*Inputs: Modifier type, value, source
*output: boolean
*
*Used to create a new Modifier and insert it into the vector.
*/
public boolean addModifier(int type, int value, String source)
{
AbilityModifier AM = new AbilityModifier();
AM.setAbilityType(type, value, source);
return addModifier(AM);
}
/*
* uniqueModifier
*
* inputs: AbilityModifier
* output: boolean
*
* returns true if this AbilityModifier does not already exist in the
vector, otherwise false.
*/
protected boolean isUnique(AbilityModifier am)
{
boolean unique = true; //set a variable to hold the uniqueness
boolean result = false;
int bound = abilityModifiers.size(); //get the size of the vector
AbilityModifier abilityModifier = new AbilityModifier(); //declare
a Feat to use with the vector
if(bound == 0)
{
return true; //the vector is empty.
}
else
{
for(int i = 0; i < bound; i++)
{
abilityModifier = (AbilityModifier)abilityModifiers.get(i); //get
an AbilityModifier from the vector
result = am.equals(abilityModifier);
if(result == true)
{
return false;
}
}
}
return unique;
}
/**
* getAbilityModifier
*
* Inputs: int
* Output: AbilityModifier
*
* returns and AbilityModifier found at index or null
*/
public AbilityModifier getAbilityModifier(int index)
{
if(index < abilityModifiers.size())
{
return (AbilityModifier)abilityModifiers.get(index);
}
else
{
return null;
}
}
/* getModifierByType
*
* Inputs: abilityType, instance
* Output: AbilityModifier
*
* Used to search the vector for the first n'th of that modifier type
and return it.
*/
public AbilityModifier getModifierByType(int abilityType, int
instance)
{
int counter = 0;
AbilityModifier AM = new AbilityModifier();
for(int i = 0; i < abilityModifiers.size(); i++)
{
AM = (AbilityModifier)abilityModifiers.get(i);
if(AM.getAbilityType() == abilityType)
{
counter++;
if(counter == instance)
{
return AM;
}
}
}
return null;
}
/**
* moveFirst()
*
* Inputs: none
* Output: boolean
*
* sets the value of 'current' to 0 (first element) if there is one.
* If there is no element at index 0, then return false, if there
is, return true.
*/
public boolean moveFirst()
{
if( abilityModifiers.size() > 0 )
{
current = 0;
return true;
}
return false;
}
/**
* getFirst
*
* Inputs: None
* Output: AbilityModifier
*
* Returns the first AbilityModifier (if there is one) otherwise
null
*/
public AbilityModifier getFirst()
{
boolean result;
result = moveFirst();
if( result = false )
{
return null;
}
else
{
return getAbilityModifier(current);
}
}
/**
* getNext
*
* Inputs: none
* Output: AbilityModifier
*
* Returns the 'next' ability modifier or null.
*/
public AbilityModifier getNext()
{
if((current +1) < abilityModifiers.size())
{
current++;
return getAbilityModifier(current);
}
return null;
}
/*
* readFromStream
*
* Inputs: XMLDecoder
* Output: AbilityModifiers object
*
* Reads XML and returns an object of Type AbilityModifiers
*/
public AbilityModifiers readFromStream( XMLDecoder in ) throws
Exception
{
Vector v = (Vector<AbilityModifier>)(in.readObject());
return new AbilityModifiers( v );
}
/*
* writeToStream
*
* Inputs: XMLEncoder
* Output: None
*
* Writes the vector of abilityModifiers to a stream using XMLEncoder
*/
public void writeToStream( XMLEncoder out ) throws Exception
{
out.writeObject( abilityModifiers );
}
/*
* saveXML
*
* Inputs: fully Qualified file name
* Output: none
*
* Writes this object to XML file
*/
public void saveXML(String fileName)
{
// write it to a file
try
{
XMLEncoder e = new XMLEncoder( new BufferedOutputStream( new
FileOutputStream(fileName)));
this.writeToStream( e );
e.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
************ Note: at the bottom there are some functions to serialize
the VECTOR in the AbilityModifiers class. it works, but I don't want
to have to serialize each component or part of my class if I can avoid
it. Also I need to serialize at the top level (Race). I hope that
makes sense...***********
**************************
here is my code that I use to test my race class (I call this from
'main' ):*
*************************
private static void testRace()
{
Race r = new Race();
r.setRaceID(1);
r.setRaceName("Elf");
r.setRaceDescriptionShort("A slim built humanoid. Highly dextrous
and long lived");
r.setRaceDescriptionLong("Elven characters make great rangers.
They tend not to make good Paladins due to their chaotic tendencise");
r.setRaceSource("PH 124");
r.setStrModifier(-1);
r.setDexModifier(1);
r.setConModifier(-1);
r.setIntModifier(1);
r.setChaModifier(1);
System.out.println(r.getRaceName() + " " + r.getRaceID());
System.out.println(r.getRaceDescriptionShort());
System.out.println(r.getRaceDescriptionLong());
System.out.println(r.getRaceSource());
System.out.println("Strength Modifiers: ");
AbilityModifier am = new AbilityModifier();
int instance = 1;
while((am = r.getModifier(instance, Ability.STRENGTH)) != null)
{
System.out.println(am.getSource() + " " + am.getValue());
instance++;
}
instance = 1;
System.out.println("Dexterity Modifiers: ");
while((am = r.getModifier(instance, Ability.DEXTERITY)) != null)
{
System.out.println(am.getSource() + " " + am.getValue());
instance++;
}
//AMs.saveXML(rootDir + "\\Feats\\AbilityModifiers.xml");
try
{
SandysXMLWriter.write(r, rootDir + "\\Races", r.getRaceName() +
".xml");
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
*******************************************************************
*** SandysXMLWriter:*****
The code I use to write the XML
*******************************************************************
/**
* @(#)SandysXMLWriter.java
*
*
* @author Sandy Murdock
* @version 1.00 2007/2/8
*
*From code found on the Net.
*/
import java.beans.XMLEncoder;
import java.beans.XMLDecoder;
import java.io.*;
import java.util.Vector;
public class SandysXMLWriter
{
public static void write(Feat o, String subDir, String fileName)
throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
public static void write(Ability o, String subDir, String
fileName) throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
public static void write(Race o, String subDir, String fileName)
throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
public static void write(Language o, String subDir, String
fileName) throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
public static Feat readFeat(String fileName) throws Exception
{
XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(new
FileInputStream(fileName)));
Feat f = (Feat)decoder.readObject();
decoder.close();
return f;
}
public static Language readLanguage(String fileName) throws Exception
{
XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(new
FileInputStream(fileName)));
Language l = (Language)decoder.readObject();
decoder.close();
return l;
}
public static void write(AbilityModifiers o, String subDir, String
fileName) throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
public static void write(AbilityModifier o, String subDir, String
fileName) throws Exception
{
XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new
FileOutputStream(subDir + "\\" + fileName)));
encoder.writeObject(o);
encoder.close();
}
}