MusicXML Tasks: Java Beans

The Java bean object model

A Java bean is a class consisting of a zero-argument constructor and zero or more data members (attributes). Each attribute has an accompanying pair of get and set methods to manipulate attribute values.

The consistent form of a Java bean allows it to be used by a framework which expects bean classes to be in a predictable form. The framework used in the tasks application is the Hibernate object-relational mapping tool.

Mapping from schema to bean

Each tasks application Java bean is a mapping of some part of the MusicXML schema.

Once the schema has been mapped to Java beans, each bean entity then maps to a database table, and the bean attributes map to columns in the table using Hibernate annotations.

The process of mapping a schema to a Java objects here is a standard one.

In general, these mappings are:

An element, or a group or complexType definition of an element, is a bean, particularly when the element used by more than one structure, or can appear as a subelement multiple times
Element text, an element attribute, or an element defined by a simpleType or scalar value that is used only once, is a bean attribute
An attributeGroup or a simpleContent that is used only once have each of their values mapped as individual attributes of a single bean
A choice is an abstract superclass with each item in the choice a concrete Java bean subclass of the abstract class
An enumeration is a Java enum whose value is a bean attribute

Bean examples

measure and music-data

The measure element in the MusicXML schema is defined as:

<xs:element name="measure" maxOccurs="unbounded">
    <xs:complexType>
        <xs:group ref="music-data"/>
        <xs:attributeGroup ref="measure-attributes"/>
    </xs:complexType>
</xs:element>

<xs:attributeGroup name="measure-attributes">
    <xs:attribute name="number" type="xs:token" use="required"/>
    <xs:attribute name="text" type="measure-text"/>
    <xs:attribute name="implicit" type="yes-no"/>
    <xs:attribute name="non-controlling" type="yes-no"/>
    <xs:attribute name="width" type="tenths"/>
    <xs:attributeGroup ref="optional-unique-id"/>
</xs:attributeGroup>

The measure element maps to a Measure bean, and the attributeGroup measure-attributes map to a collection of bean attributes.

The Measure bean is thus defined as follows:

package com.musicxmltasks.musicxml.score;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class Measure extends OrderedElement {
    private String number;
    private String text;
    private Boolean implicit;
    private Boolean nonControlling;
    private BigDecimal width;
    private List<MusicData> musicDataList = new ArrayList<>();

    public Measure() {

    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public Boolean getImplicit() {
        return implicit;
    }

    public void setImplicit(Boolean implicit) {
        this.implicit = implicit;
    }

    public Boolean getNonControlling() {
        return nonControlling;
    }

    public void setNonControlling(Boolean nonControlling) {
        this.nonControlling = nonControlling;
    }

    public BigDecimal getWidth() {
        return width;
    }

    public void setWidth(BigDecimal width) {
        this.width = width;
    }

    public List<MusicData> getMusicDataList() {
        return musicDataList;
    }

    public void setMusicDataList(List<MusicData> musicDataList) {
        this.musicDataList = musicDataList;
    }
}

The music-data group referenced within the measure element definition is defined as a list of a choice subelements of the measure element.

<xs:group name="music-data">
    <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element name="note" type="note"/>
            <xs:element name="backup" type="backup"/>
            <xs:element name="forward" type="forward"/>
            <xs:element name="direction" type="direction"/>
            <xs:element name="attributes" type="attributes"/>
            <xs:element name="harmony" type="harmony"/>
            <xs:element name="figured-bass" type="figured-bass"/>
            <xs:element name="print" type="print"/>
            <xs:element name="sound" type="sound"/>
            <xs:element name="listening" type="listening"/>
            <xs:element name="barline" type="barline"/>
            <xs:element name="grouping" type="grouping"/>
            <xs:element name="link" type="link"/>
            <xs:element name="bookmark" type="bookmark"/>
        </xs:choice>
    </xs:sequence>
</xs:group>

The choice construct itself is an abstract superclass, while the individual elements within the choice are each concrete subclasses of the abstract class.

The MusicData class represents the choice element:

package com.musicxmltasks.musicxml.score;

import com.musicxmltasks.database.OrderedItem;

public abstract class MusicData extends OrderedItem {

}

The note element (to take an example) is one of the choice options, and maps to the Note subclass [class MusicDataElement is a subclass of MusicData that includes optional-unique-id]:

package com.musicxmltasks.musicxml.note;

import com.musicxmltasks.lilypond.util.TypeUtil;
import com.musicxmltasks.musicxml.common.SymbolSize;
import com.musicxmltasks.musicxml.display.TextDisplay;
import com.musicxmltasks.musicxml.display.Editorial;
import com.musicxmltasks.musicxml.common.Printout;
import com.musicxmltasks.musicxml.common.play.Play;
import com.musicxmltasks.musicxml.display.Display;
import com.musicxmltasks.musicxml.note.lyric.Lyric;
import com.musicxmltasks.musicxml.score.MusicDataElement;
import com.musicxmltasks.util.MathUtil;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class Note extends MusicDataElement {
    private Grace grace;
    private Boolean cue = false;
    private NoteType noteType;
    private Boolean chord = false;
    private BigDecimal duration = MathUtil.ZERO;
    private List<Tie> ties = new ArrayList<>();
    private String instrument;
    private Editorial editorial;
    private String voice;
    private NoteTypeValue noteValue;
    private SymbolSize noteSize;
    private List<Dot> dots = new ArrayList<>();
    private Accidental accidental;
    private TimeModification timeModification;
    private Stem stem;
    private Notehead notehead;
    private List<TextDisplay> noteheadTextList = new ArrayList<>();
    private Integer staff;
    private List<Beam> beams = new ArrayList<>();
    private List<Notations> notationsList = new ArrayList<>();
    private List<Lyric> lyrics = new ArrayList<>();
    private Play play;
    private Display display;
    private Printout printout;
    private Boolean printLeger;
    private BigDecimal dynamics;
    private BigDecimal endDynamics;
    private BigDecimal attack;
    private BigDecimal release;
    private String timeOnly;
    private Boolean pizzicato;

    public Note() {

    }

    public Grace getGrace() {
        return grace;
    }

    public void setGrace(Grace grace) {
        this.grace = grace;
    }

    public boolean isGraceNote() {
        return grace != null;
    }

    public Boolean getCue() {
        return cue;
    }

    public void setCue(Boolean cue) {
        this.cue = cue;
    }

    public NoteType getNoteType() {
        return noteType;
    }

    public void setNoteType(NoteType noteType) {
        this.noteType = noteType;
    }

    public Boolean isChord() {
        return chord;
    }

    public void setChord(Boolean chord) {
        this.chord = chord;
    }

    public BigDecimal getDuration() {
        return duration;
    }

    public void setDuration(BigDecimal duration) {
        this.duration = duration;
    }

    public List<Tie> getTies() {
        return ties;
    }

    public void setTies(List<Tie> ties) {
        this.ties = ties;
    }

    public String getInstrument() {
        return instrument;
    }

    public void setInstrument(String instrument) {
        this.instrument = instrument;
    }

    public Editorial getEditorial() {
        return editorial;
    }

    public void setEditorial(Editorial editorial) {
        this.editorial = editorial;
    }

    public String getVoice() {
        return voice;
    }

    public void setVoice(String voice) {
        this.voice = voice;
    }

    public NoteTypeValue getNoteValue() {
        return noteValue;
    }

    public void setNoteValue(NoteTypeValue noteValue) {
        this.noteValue = noteValue;
    }

    public SymbolSize getNoteSize() {
        return noteSize;
    }

    public void setNoteSize(SymbolSize noteSize) {
        this.noteSize = noteSize;
    }

    public List<Dot> getDots() {
        return dots;
    }

    public void setDots(List<Dot> dots) {
        this.dots = dots;
    }

    public Accidental getAccidental() {
        return accidental;
    }

    public void setAccidental(Accidental accidental) {
        this.accidental = accidental;
    }

    public TimeModification getTimeModification() {
        return timeModification;
    }

    public void setTimeModification(TimeModification timeModification) {
        this.timeModification = timeModification;
    }

    public Stem getStem() {
        return stem;
    }

    public void setStem(Stem stem) {
        this.stem = stem;
    }

    public Notehead getNotehead() {
        return notehead;
    }

    public void setNotehead(Notehead notehead) {
        this.notehead = notehead;
    }

    public List<TextDisplay> getNoteheadTextList() {
        return noteheadTextList;
    }

    public void setNoteheadTextList(List<TextDisplay> noteheadTextList) {
        this.noteheadTextList = noteheadTextList;
    }

    public Integer getStaff() {
        return staff;
    }

    public void setStaff(Integer staff) {
        this.staff = staff;
    }

    public List<Beam> getBeams() {
        return beams;
    }

    public void setBeams(List<Beam> beams) {
        this.beams = beams;
    }

    public List<Notations> getNotationsList() {
        return notationsList;
    }

    public void setNotationsList(List<Notations> notationsList) {
        this.notationsList = notationsList;
    }

    public List<Lyric> getLyrics() {
        return lyrics;
    }

    public void setLyrics(List<Lyric> lyrics) {
        this.lyrics = lyrics;
    }

    public Play getPlay() {
        return play;
    }

    public void setPlay(Play play) {
        this.play = play;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }

    public Printout getPrintout() {
        return printout;
    }

    public void setPrintout(Printout printout) {
        this.printout = printout;
    }

    public Boolean getPrintLeger() {
        return printLeger;
    }

    public void setPrintLeger(Boolean printLeger) {
        this.printLeger = printLeger;
    }

    public BigDecimal getDynamics() {
        return dynamics;
    }

    public void setDynamics(BigDecimal dynamics) {
        this.dynamics = dynamics;
    }

    public BigDecimal getEndDynamics() {
        return endDynamics;
    }

    public void setEndDynamics(BigDecimal endDynamics) {
        this.endDynamics = endDynamics;
    }

    public BigDecimal getAttack() {
        return attack;
    }

    public void setAttack(BigDecimal attack) {
        this.attack = attack;
    }

    public BigDecimal getRelease() {
        return release;
    }

    public void setRelease(BigDecimal release) {
        this.release = release;
    }

    public String getTimeOnly() {
        return timeOnly;
    }

    public void setTimeOnly(String timeOnly) {
        this.timeOnly = timeOnly;
    }

    public Boolean getPizzicato() {
        return pizzicato;
    }

    public void setPizzicato(Boolean pizzicato) {
        this.pizzicato = pizzicato;
    }
}

metronome

A less straightforward example of a mapping of a choice is the metronome complexType.

When a choice has an unnamed sequence, I map the sequence to a bean subclass using a name that I feel represents the sequence.

The metronome complexType is defined as follows:

<xs:complexType name="metronome">
    <xs:choice>
        <xs:sequence>
            <xs:group ref="beat-unit"/>
            <xs:element name="beat-unit-tied" type="beat-unit-tied" minOccurs="0" maxOccurs="unbounded"/>
            <xs:choice>
                <xs:element name="per-minute" type="per-minute"/>
                <xs:sequence>
                    <xs:group ref="beat-unit"/>
                    <xs:element name="beat-unit-tied" type="beat-unit-tied" minOccurs="0" maxOccurs="unbounded"/>
                </xs:sequence>
            </xs:choice>
        </xs:sequence>
        <xs:sequence>
            <xs:element name="metronome-arrows" type="empty" minOccurs="0">
            </xs:element>
            <xs:element name="metronome-note" type="metronome-note" maxOccurs="unbounded"/>
            <xs:sequence minOccurs="0">
                <xs:element name="metronome-relation" type="xs:string">
                </xs:element>
                <xs:element name="metronome-note" type="metronome-note" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:sequence>
    </xs:choice>
    <xs:attributeGroup ref="print-style-align"/>
    <xs:attributeGroup ref="print-object"/>
    <xs:attributeGroup ref="justify"/>
    <xs:attribute name="parentheses" type="yes-no"/>
    <xs:attributeGroup ref="optional-unique-id"/>
</xs:complexType>

The Metronome abstract class is the mapping of the metronome complexType as a whole:

package com.musicxmltasks.musicxml.direction.directiontype.metronome;

import com.musicxmltasks.musicxml.direction.directiontype.DirectionType;
import com.musicxmltasks.musicxml.display.Halign;

public abstract class Metronome extends DirectionType {
    private Boolean printObject;
    private Halign justify;
    private Boolean parentheses;

    public Boolean getPrintObject() {
        return printObject;
    }

    public void setPrintObject(Boolean printObject) {
        this.printObject = printObject;
    }

    public Halign getJustify() {
        return justify;
    }

    public void setJustify(Halign justify) {
        this.justify = justify;
    }

    public Boolean getParentheses() {
        return parentheses;
    }

    public void setParentheses(Boolean parentheses) {
        this.parentheses = parentheses;
    }
}

The Java beans BeatMetronome and NoteMetronome are concrete subclasses of Metronome, where each bean type is a mapping of one of the sequence elements in the choice.

The NoteMetronome bean is the mapping of the second sequence:

package com.musicxmltasks.musicxml.direction.directiontype.metronome;

import java.util.ArrayList;
import java.util.List;

public class NoteMetronome extends Metronome {
    private Boolean metronomeArrows = false;
    private List<MetronomeNote> metronomeNotes1 = new ArrayList<>();
    private String metronomeRelation;
    private List<MetronomeNote> metronomeNotes2 = new ArrayList<>();

    public NoteMetronome() {

    }

    public Boolean getMetronomeArrows() {
        return metronomeArrows;
    }

    public void setMetronomeArrows(Boolean metronomeArrows) {
        this.metronomeArrows = metronomeArrows;
    }

    public List<MetronomeNote> getMetronomeNotes1() {
        return metronomeNotes1;
    }

    public void setMetronomeNotes1(List<MetronomeNote> metronomeNotes1) {
        this.metronomeNotes1 = metronomeNotes1;
    }

    public String getMetronomeRelation() {
        return metronomeRelation;
    }

    public void setMetronomeRelation(String metronomeRelation) {
        this.metronomeRelation = metronomeRelation;
    }

    public List<MetronomeNote> getMetronomeNotes2() {
        return metronomeNotes2;
    }

    public void setMetronomeNotes2(List<MetronomeNote> metronomeNotes2) {
        this.metronomeNotes2 = metronomeNotes2;
    }

}

The BeatMetronome bean is the mapping of the first sequence, reproduced below:

<xs:sequence>
    <xs:group ref="beat-unit"/>
    <xs:element name="beat-unit-tied" type="beat-unit-tied" minOccurs="0" maxOccurs="unbounded"/>
    <xs:choice>
        <xs:element name="per-minute" type="per-minute"/>
        <xs:sequence>
            <xs:group ref="beat-unit"/>
            <xs:element name="beat-unit-tied" type="beat-unit-tied" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:choice>
</xs:sequence>

The choice section within the sequence is mapped as abstract class MetronomeMark, with two concrete subclasses PerMinute and BeatUnit; BeatUnit represents the beat-unit/beat-unit-tied sequence.

package com.musicxmltasks.musicxml.direction.directiontype.metronome;

import com.musicxmltasks.musicxml.display.Display;

public class PerMinute extends MetronomeMark {
    private String value;
    private Display display;

    public PerMinute() {

    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }
}

package com.musicxmltasks.musicxml.direction.directiontype.metronome;

import com.musicxmltasks.musicxml.note.NoteTypeValue;

import java.util.ArrayList;
import java.util.List;

public class BeatUnit extends MetronomeMark {
    private NoteTypeValue value;
    private Integer beatUnitDots = 0;
    private List<BeatUnit> beatUnitTieds = new ArrayList<>();

    public BeatUnit() {

    }

    public NoteTypeValue getValue() {
        return value;
    }

    public void setValue(NoteTypeValue value) {
        this.value = value;
    }

    public Integer getBeatUnitDots() {
        return beatUnitDots;
    }

    public void setBeatUnitDots(Integer beatUnitDots) {
        this.beatUnitDots = beatUnitDots;
    }

    public List<BeatUnit> getBeatUnitTieds() {
        return beatUnitTieds;
    }

    public void setBeatUnitTieds(List<BeatUnit> beatUnitTieds) {
        this.beatUnitTieds = beatUnitTieds;
    }
}

The BeatMetronome sequence as a whole is then mapped as two MetronomeMark attributes:

package com.musicxmltasks.musicxml.direction.directiontype.metronome;

public class BeatMetronome extends Metronome {
    private MetronomeMark metronomeMark1;
    private MetronomeMark metronomeMark2;

    public BeatMetronome() {

    }

    public MetronomeMark getMetronomeMark1() {
        return metronomeMark1;
    }

    public void setMetronomeMark1(MetronomeMark metronomeMark1) {
        this.metronomeMark1 = metronomeMark1;
    }

    public MetronomeMark getMetronomeMark2() {
        return metronomeMark2;
    }

    public void setMetronomeMark2(MetronomeMark metronomeMark2) {
        this.metronomeMark2 = metronomeMark2;
    }
}