1:<?xml version="1.0"?>
   2:<project name="Harnessing Hibernate: The Developer's Notebook"
   3:         default="db" basedir=".">
   4:
   5:  <!-- Set up properties containing important project directories -->
   6:  <property name="source.root" value="src"/>
   7:  <property name="class.root" value="classes"/>
   8:  <property name="lib.dir" value="lib"/>
   9:  <property name="data.dir" value="data"/>
  10:
  11:  <!-- Set up the class path for compilation and execution -->
  12:  <path id="project.class.path">
  13:      <!-- Include our own classes, of course -->
  14:      <pathelement location="${class.root}" />
  15:      <!-- Include jars in the project library directory -->
  16:      <fileset dir="${lib.dir}">
  17:        <include name="*.jar"/>
  18:      </fileset>
  19:  </path>
  20:
  21:  <target name="db" description="Runs HSQLDB database management UI
  22:against the database file--use when application is not running">
  23:      <java classname="org.hsqldb.util.DatabaseManager"
  24:            fork="yes">
  25:         <classpath refid="project.class.path"/>
  26:         <arg value="-driver"/>
  27:         <arg value="org.hsqldb.jdbcDriver"/>
  28:         <arg value="-url"/>
  29:         <arg value="jdbc:hsqldb:${data.dir}/music"/>
  30:         <arg value="-user"/>
  31:         <arg value="sa"/>
  32:      </java>
  33:  </target>
  34:
  35:  <!-- Teach Ant how to use Hibernate's code generation tool -->
  36:  <taskdef name="hbm2java"
  37:           classname="net.sf.hibernate.tool.hbm2java.Hbm2JavaTask"
  38:           classpathref="project.class.path"/>
  39:
  40:  <!-- Generate the java code for all mapping files in our source tree -->
  41:  <target name="codegen" depends="prepare"
  42:          description="Generate Java source from the O/R mapping files">
  43:    <hbm2java output="${source.root}">
  44:      <fileset dir="${source.root}">
  45:        <include name="**/*.hbm.xml"/>
  46:      </fileset>
  47:    </hbm2java>
  48:  </target>
  49:
  50:  <!-- Create our runtime subdirectories and copy resources into them -->
  51:  <target name="prepare" description="Sets up build structures">
  52:    <mkdir dir="${class.root}"/>
  53:
  54:    <!-- Copy our property files and O/R mappings for use at runtime -->
  55:    <copy todir="${class.root}" >
  56:      <fileset dir="${source.root}" >
  57:        <include name="**/*.properties"/>
  58:        <include name="**/*.hbm.xml"/>
  59:      </fileset>
  60:    </copy>
  61:  </target>
  62:
  63:  <!-- Compile the java source of the project -->
  64:  <target name="compile" depends="prepare"
  65:          description="Compiles all Java classes">
  66:    <javac srcdir="${source.root}"
  67:           destdir="${class.root}"
  68:           debug="on"
  69:           optimize="off"
  70:           deprecation="on">
  71:      <classpath refid="project.class.path"/>
  72:    </javac>
  73:  </target>
  74:
  75:  <!-- Generate the schemas for all mapping files in our class tree -->
  76:  <target name="schema" depends="compile"
  77:          description="Generate DB schema from the O/R mapping files">
  78:
  79:    <!-- Teach Ant how to use Hibernate's schema generation tool -->
  80:    <taskdef name="schemaexport"
  81:             classname="net.sf.hibernate.tool.hbm2ddl.SchemaExportTask"
  82:             classpathref="project.class.path"/>
  83:
  84:    <schemaexport properties="${class.root}/hibernate.properties"
  85:                  quiet="no" text="no" drop="no">
  86:      <fileset dir="${class.root}">
  87:        <include name="**/*.hbm.xml"/>
  88:      </fileset>
  89:    </schemaexport>
  90:  </target>
  91:
  92:  <target name="ctest" description="Creates and persists some sample data"
  93:          depends="compile">
  94:    <java classname="com.oreilly.hh.CreateTest" fork="true">
  95:      <classpath refid="project.class.path"/>
  96:    </java>
  97:  </target>
  98:
  99:  <target name="qtest" description="Run a simple Hibernate query"
 100:          depends="compile">
 101:    <java classname="com.oreilly.hh.QueryTest" fork="true">
 102:      <classpath refid="project.class.path"/>
 103:    </java>
 104:  </target>
 105:
 106:</project>

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Track" table="TRACK">
   8:    <meta attribute="class-description">
   9:      Represents a single playable track in the music database.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="TRACK_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="title" type="string" not-null="true"/>
  19:
  20:    <property name="filePath" type="string" not-null="true"/>
  21:
  22:    <property name="playTime" type="time">
  23:      <meta attribute="field-description">Playing time</meta>
  24:    </property>
  25:
  26:    <property name="added" type="date">
  27:      <meta attribute="field-description">When the track was created</meta>
  28:    </property>
  29:
  30:    <property name="volume" type="short" not-null="true">
  31:      <meta attribute="field-description">How loud to play the track</meta>
  32:    </property>
  33:
  34:  </class>
  35:</hibernate-mapping>

BUILD SUCCESSFUL
Total time: 2 seconds
!

   1:package com.oreilly.hh;
   2:
   3:import java.io.Serializable;
   4:import java.util.Date;
   5:import org.apache.commons.lang.builder.ToStringBuilder;
   6:
   7:
   8:/** 
   9: *       Represents a single playable track in the music database.
  10: *       @author Jim Elliott (with help from Hibernate)
  11: *     
  12:*/
  13:public class Track implements Serializable {
  14:
  15:    /** identifier field */
  16:    private Integer id;
  17:
  18:    /** persistent field */
  19:    private String title;
  20:
  21:    /** persistent field */
  22:    private String filePath;
  23:
  24:    /** nullable persistent field */
  25:    private Date playTime;
  26:
  27:    /** nullable persistent field */
  28:    private Date added;
  29:
  30:    /** persistent field */
  31:    private short volume;
  32:
  33:    /** full constructor */
  34:    public Track(String title, String filePath, Date playTime, Date added, short volume) {
  35:        this.title = title;
  36:        this.filePath = filePath;
  37:        this.playTime = playTime;
  38:        this.added = added;
  39:        this.volume = volume;
  40:    }
  41:
  42:    /** default constructor */
  43:    public Track() {
  44:    }
  45:
  46:    /** minimal constructor */
  47:    public Track(String title, String filePath, short volume) {
  48:        this.title = title;
  49:        this.filePath = filePath;
  50:        this.volume = volume;
  51:    }
  52:
  53:    public Integer getId() {
  54:        return this.id;
  55:    }
  56:
  57:    protected void setId(Integer id) {
  58:        this.id = id;
  59:    }
  60:
  61:    public String getTitle() {
  62:        return this.title;
  63:    }
  64:
  65:    public void setTitle(String title) {
  66:        this.title = title;
  67:    }
  68:
  69:    public String getFilePath() {
  70:        return this.filePath;
  71:    }
  72:
  73:    public void setFilePath(String filePath) {
  74:        this.filePath = filePath;
  75:    }
  76:
  77:    /** 
  78:     * Playing time
  79:     */
  80:    public Date getPlayTime() {
  81:        return this.playTime;
  82:    }
  83:
  84:    public void setPlayTime(Date playTime) {
  85:        this.playTime = playTime;
  86:    }
  87:
  88:    /** 
  89:     * When the track was created
  90:     */
  91:    public Date getAdded() {
  92:        return this.added;
  93:    }
  94:
  95:    public void setAdded(Date added) {
  96:        this.added = added;
  97:    }
  98:
  99:    /** 
 100:     * How loud to play the track
 101:     */
 102:    public short getVolume() {
 103:        return this.volume;
 104:    }
 105:
 106:    public void setVolume(short volume) {
 107:        this.volume = volume;
 108:    }
 109:
 110:    public String toString() {
 111:        return new ToStringBuilder(this)
 112:            .append("id", getId())
 113:            .toString();
 114:    }
 115:
 116:}

BUILD SUCCESSFUL
Total time: 4 seconds

mysql> use hibernate
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
         mysql> show tables;
         +---------------------+
         | Tables_in_hibernate |
         +---------------------+
         | TRACK |
         +---------------------+
         1 row in set (0.00 sec)

mysql> desc TRACK;
         +----------+--------------+------+-----+---------+----------------+
         | Field | Type | Null | Key | Default | Extra |
         +----------+--------------+------+-----+---------+----------------+
         | TRACK_ID | int(11) | | PRI | NULL | auto_increment |
         | title | varchar(255) | | | | |
         | filePath | varchar(255) | | | | |
         | playTime | time | YES | | NULL | |
         | added | date | YES | | NULL | |
         | volume | smallint(6) | | | 0 | |
         +----------+--------------+------+-----+---------+----------------+
         6 rows in set (0.01 sec)
       

   1:package com.oreilly.hh;
   2:
   3:import net.sf.hibernate.*;
   4:import net.sf.hibernate.cfg.Configuration;
   5:
   6:import java.sql.Time;
   7:import java.util.Date;
   8:
   9:/**
  10: * Create sample data, letting Hibernate persist it for us.
  11: */
  12:public class CreateTest {
  13:
  14:    public static void main(String args[]) throws Exception {
  15:        // Create a configuration based on the properties file we've put
  16:        // in the standard place.
  17:        Configuration config = new Configuration();
  18:
  19:        // Tell it about the classes we want mapped, taking advantage of
  20:        // the way we've named their mapping documents.
  21:        config.addClass(Track.class);
  22:
  23:        // Get the session factory we can use for persistence
  24:        SessionFactory sessionFactory = config.buildSessionFactory();
  25:
  26:        // Ask for a session using the JDBC information we've configured
  27:        Session session = sessionFactory.openSession();
  28:        Transaction tx = null;
  29:        try {
  30:            // Create some data and persist it
  31:            tx = session.beginTransaction();
  32:
  33:            Track track = new Track("Russian Trance",
  34:                                    "vol2/album610/track02.mp3",
  35:                                    Time.valueOf("00:03:30"), new Date(),
  36:                                    (short)0);
  37:            session.save(track);
  38:
  39:            track = new Track("Video Killed the Radio Star",
  40:                              "vol2/album611/track12.mp3",
  41:                              Time.valueOf("00:03:49"), new Date(),
  42:                              (short)0);
  43:            session.save(track);
  44:
  45:            
  46:             track = new Track("Gravity's Angel",
  47:                              "vol2/album175/track03.mp3",
  48:                               Time.valueOf("00:06:06"), new Date(),
  49:                               (short)0);
  50:            session.save(track);
  51:
  52:            // We're done; make our changes permanent
  53:            tx.commit();
  54:
  55:        } catch (Exception e) {
  56:            if (tx != null) {
  57:                // Something went wrong; discard all partial changes
  58:                tx.rollback();
  59:            }
  60:            throw e;
  61:        } finally {
  62:            // No matter what, close the session
  63:            session.close();
  64:        }
  65:
  66:        // Clean up after ourselves
  67:        sessionFactory.close();
  68:    }
  69:}

digital@localhost:~/SourceExamples/SourceExamples/ch03> ant ctest
Buildfile: build.xml

prepare:
[copy] Copying 1 file to /home/digital/SourceExamples/SourceExamples/ch03/classes

compile:
[javac] Compiling 3 source files to /home/digital/SourceExamples/SourceExamples/ch03/classes

ctest:
[java] 00:27:12,169 INFO Environment:478 - Hibernate 2.1.7
[java] 00:27:12,190 INFO Environment:512 - loaded properties from resource hibernate.properties: {hibernate.connection.username=root, hibernate.connection.password=lolo, hibernate.cglib.use_reflection_optimizer=true, hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect, hibernate.connection.url=jdbc:mysql://localhost:9097/hibernate, hibernate.connection.driver_class=org.gjt.mm.mysql.Driver}
[java] 00:27:12,206 INFO Environment:538 - using CGLIB reflection optimizer
[java] 00:27:12,212 INFO Environment:567 - using JDK 1.4 java.sql.Timestamp handling
[java] 00:27:12,219 INFO Configuration:350 - Mapping resource: com/oreilly/hh/Track.hbm.xml
[java] 00:27:13,191 INFO Binder:230 - Mapping class: com.oreilly.hh.Track -> TRACK
[java] 00:27:13,342 INFO Configuration:632 - processing one-to-many association mappings
[java] 00:27:13,344 INFO Configuration:641 - processing one-to-one association property references
[java] 00:27:13,345 INFO Configuration:666 - processing foreign key constraints
[java] 00:27:13,399 INFO Dialect:86 - Using dialect: net.sf.hibernate.dialect.MySQLDialect
[java] 00:27:13,419 INFO SettingsFactory:70 - Maximim outer join fetch depth: 2
[java] 00:27:13,421 INFO SettingsFactory:74 - Use outer join fetching: true
[java] 00:27:13,438 INFO DriverManagerConnectionProvider:42 - Using Hibernate built-in connection pool (not for production use!)
[java] 00:27:13,440 INFO DriverManagerConnectionProvider:43 - Hibernate connection pool size: 20
[java] 00:27:13,451 INFO DriverManagerConnectionProvider:77 - using driver: org.gjt.mm.mysql.Driver at URL: jdbc:mysql://localhost:9097/hibernate
[java] 00:27:13,460 INFO DriverManagerConnectionProvider:78 - connection properties: {user=root, password=lolo}
[java] 00:27:13,483 INFO TransactionManagerLookupFactory:33 - No TransactionManagerLookup configured (in JTA environment, use of process level read-write cache is not recommended)
[java] 00:27:13,831 INFO SettingsFactory:114 - Use scrollable result sets: true
[java] 00:27:13,833 INFO SettingsFactory:117 - Use JDBC3 getGeneratedKeys(): true
[java] 00:27:13,834 INFO SettingsFactory:120 - Optimize cache for minimal puts: false
[java] 00:27:13,841 INFO SettingsFactory:129 - Query language substitutions: {}
[java] 00:27:13,843 INFO SettingsFactory:140 - cache provider: net.sf.hibernate.cache.EhCacheProvider
[java] 00:27:13,847 INFO Configuration:1121 - instantiating and configuring caches
[java] 00:27:14,060 INFO SessionFactoryImpl:119 - building session factory
[java] 00:27:14,617 INFO SessionFactoryObjectFactory:82 - Not binding factory to JNDI, no JNDI name configured
[java] 00:27:14,858 INFO SessionFactoryImpl:540 - closing
[java] 00:27:14,861 INFO DriverManagerConnectionProvider:143 - cleaning up connection pool: jdbc:mysql://localhost:9097/hibernate

BUILD SUCCESSFUL
Total time: 5 seconds

mysql> select * from TRACK;
       +----------+-----------------------------+---------------------------+----------+------------+--------+
       | TRACK_ID | title | filePath | playTime | added | volume |
       +----------+-----------------------------+---------------------------+----------+------------+--------+
       | 1 | Russian Trance | vol2/album610/track02.mp3 | 00:03:30 | 2005-02-15        | 0 |
       | 2 | Video Killed the Radio Star | vol2/album611/track12.mp3 | 00:03:49        | 2005-02-15 | 0 |
       | 3 | Gravity's Angel | vol2/album175/track03.mp3 | 00:06:06 | 2005-02-15        | 0 |
       +----------+-----------------------------+---------------------------+----------+------------+--------+
       3 rows in set (0.00 sec)

   1:package com.oreilly.hh;
   2:
   3:import net.sf.hibernate.*;
   4:import net.sf.hibernate.cfg.Configuration;
   5:
   6:import java.sql.Time;
   7:import java.util.*;
   8:
   9:/**
  10: * Retrieve data as objects
  11: */
  12:public class QueryTest {
  13:
  14:    /**
  15:     * Retrieve any tracks that fit in the specified amount of time.
  16:     *
  17:     * @param length the maximum playing time for tracks to be returned.
  18:     * @param session the Hibernate session that can retrieve data.
  19:     * @return a list of {@link Track}s meeting the length restriction.
  20:     * @throws HibernateException if there is a problem.
  21:     */
  22:    public static List tracksNoLongerThan(Time length, Session session)
  23:        throws HibernateException
  24:    {
  25:        Query query = session.getNamedQuery(
  26:                          "com.oreilly.hh.tracksNoLongerThan");
  27:        query.setTime("length", length);
  28:        return query.list();
  29:    }   
  30:
  31:    /**
  32:     * Look up and print some tracks when invoked from the command line.
  33:     */
  34:    public static void main(String args[]) throws Exception {
  35:        // Create a configuration based on the properties file we've put
  36:        // in the standard place.
  37:        Configuration config = new Configuration();
  38:
  39:        // Tell it about the classes we want mapped, taking advantage of
  40:        // the way we've named their mapping documents.
  41:        config.addClass(Track.class);
  42:
  43:        // Get the session factory we can use for persistence
  44:        SessionFactory sessionFactory = config.buildSessionFactory();
  45:
  46:        // Ask for a session using the JDBC information we've configured
  47:        Session session = sessionFactory.openSession();
  48:        try {
  49:            // Print the tracks that will fit in five minutes
  50:            List tracks = tracksNoLongerThan(Time.valueOf("00:05:00"),
  51:                                             session);
  52:            for (ListIterator iter = tracks.listIterator() ;
  53:                 iter.hasNext() ; ) {
  54:                Track aTrack = (Track)iter.next();
  55:                System.out.println("Track: \"" + aTrack.getTitle() +
  56:                                   "\", " + aTrack.getPlayTime());
  57:            }
  58:        } finally {
  59:            // No matter what, close the session
  60:            session.close();
  61:        }
  62:
  63:        // Clean up after ourselves
  64:        sessionFactory.close();
  65:    }
  66:}

BUILD SUCCESSFUL
Total time: 5 seconds

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Track" table="TRACK">
   8:    <meta attribute="class-description">
   9:      Represents a single playable track in the music database.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="TRACK_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="title" type="string" not-null="true"/>
  19:
  20:    <property name="filePath" type="string" not-null="true"/>
  21:
  22:    <property name="playTime" type="time">
  23:      <meta attribute="field-description">Playing time</meta>
  24:    </property>
  25:
  26:    <property name="added" type="date">
  27:      <meta attribute="field-description">When the track was created</meta>
  28:    </property>
  29:
  30:    <property name="volume" type="short" not-null="true">
  31:      <meta attribute="field-description">How loud to play the track</meta>
  32:    </property>
  33:
  34:  </class>
  35:
  36:  <query name="com.oreilly.hh.tracksNoLongerThan">
  37:    <![CDATA[
  38:        from com.oreilly.hh.Track as track
  39:        where track.playTime <= :length
  40:      ]]>

  41:  </query>
  42:
  43:</hibernate-mapping>

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Track" table="TRACK">
   8:    <meta attribute="class-description">
   9:      Represents a single playable track in the music database.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="TRACK_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="title" type="string">
  19:      <meta attribute="use-in-tostring">true</meta>
  20:      <column name="TITLE" not-null="true" index="TRACK_TITLE"/>
  21:    </property>
  22:
  23:    <property name="filePath" type="string" not-null="true"/>
  24:
  25:    <property name="playTime" type="time">
  26:      <meta attribute="field-description">Playing time</meta>
  27:    </property>
  28:
  29:    <set name="artists" table="TRACK_ARTISTS">
  30:      <key column="TRACK_ID"/>
  31:      <many-to-many class="com.oreilly.hh.Artist" column="ARTIST_ID"/>
  32:    </set>
  33:
  34:    <set name="comments" table="TRACK_COMMENTS">
  35:      <key column="TRACK_ID"/>
  36:      <element column="COMMENT" type="string"/>
  37:    </set>
  38:
  39:    <property name="added" type="date">
  40:      <meta attribute="field-description">When the track was created</meta>
  41:    </property>
  42:
  43:    <property name="volume" type="short" not-null="true">
  44:      <meta attribute="field-description">How loud to play the track</meta>
  45:    </property>
  46:
  47:  </class>
  48:
  49:  <query name="com.oreilly.hh.tracksNoLongerThan">
  50:    <![CDATA[
  51:        from com.oreilly.hh.Track as track
  52:        where track.playTime <= :length
  53:      ]]>
  54:  </query>
  55:
  56:</hibernate-mapping>

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Artist" table="ARTIST">
   8:    <meta attribute="class-description">
   9:      Represents an artist who is associated with a track or album.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="ARTIST_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="name" type="string">
  19:      <meta attribute="use-in-tostring">true</meta>
  20:      <column name="NAME" not-null="true" unique="true" index="ARTIST_NAME"/>
  21:    </property>
  22:
  23:    <set name="tracks" table="TRACK_ARTISTS" inverse="true">
  24:      <meta attribute="field-description">Tracks by this artist</meta>
  25:      <key column="ARTIST_ID"/>
  26:      <many-to-many class="com.oreilly.hh.Track" column="TRACK_ID"/>
  27:    </set>
  28:
  29:  </class>
  30:
  31:  <query name="com.oreilly.hh.artistByName">
  32:    <![CDATA[
  33:        from com.oreilly.hh.Artist as artist
  34:        where upper(artist.name) = upper(:name)
  35:      ]]>
  36:  </query>
  37:
  38:</hibernate-mapping>

BUILD SUCCESSFUL
Total time: 3 seconds

   1:package com.oreilly.hh;
   2:
   3:import java.io.Serializable;
   4:import java.util.Date;
   5:import java.util.Set;
   6:import org.apache.commons.lang.builder.ToStringBuilder;
   7:
   8:
   9:/** 
  10: *       Represents a single playable track in the music database.
  11: *       @author Jim Elliott (with help from Hibernate)
  12: *     
  13:*/
  14:public class Track implements Serializable {
  15:
  16:    /** identifier field */
  17:    private Integer id;
  18:
  19:    /** nullable persistent field */
  20:    private String title;
  21:
  22:    /** persistent field */
  23:    private String filePath;
  24:
  25:    /** nullable persistent field */
  26:    private Date playTime;
  27:
  28:    /** nullable persistent field */
  29:    private Date added;
  30:
  31:    /** persistent field */
  32:    private short volume;
  33:
  34:    /** persistent field */
  35:    private Set artists;
  36:
  37:    /** persistent field */
  38:    private Set comments;
  39:
  40:    /** full constructor */
  41:    public Track(String title, String filePath, Date playTime, Date added, short volume, Set artists, Set comments) {
  42:        this.title = title;
  43:        this.filePath = filePath;
  44:        this.playTime = playTime;
  45:        this.added = added;
  46:        this.volume = volume;
  47:        this.artists = artists;
  48:        this.comments = comments;
  49:    }
  50:
  51:    /** default constructor */
  52:    public Track() {
  53:    }
  54:
  55:    /** minimal constructor */
  56:    public Track(String filePath, short volume, Set artists, Set comments) {
  57:        this.filePath = filePath;
  58:        this.volume = volume;
  59:        this.artists = artists;
  60:        this.comments = comments;
  61:    }
  62:
  63:    public Integer getId() {
  64:        return this.id;
  65:    }
  66:
  67:    protected void setId(Integer id) {
  68:        this.id = id;
  69:    }
  70:
  71:    public String getTitle() {
  72:        return this.title;
  73:    }
  74:
  75:    public void setTitle(String title) {
  76:        this.title = title;
  77:    }
  78:
  79:    public String getFilePath() {
  80:        return this.filePath;
  81:    }
  82:
  83:    public void setFilePath(String filePath) {
  84:        this.filePath = filePath;
  85:    }
  86:
  87:    /** 
  88:     * Playing time
  89:     */
  90:    public Date getPlayTime() {
  91:        return this.playTime;
  92:    }
  93:
  94:    public void setPlayTime(Date playTime) {
  95:        this.playTime = playTime;
  96:    }
  97:
  98:    /** 
  99:     * When the track was created
 100:     */
 101:    public Date getAdded() {
 102:        return this.added;
 103:    }
 104:
 105:    public void setAdded(Date added) {
 106:        this.added = added;
 107:    }
 108:
 109:    /** 
 110:     * How loud to play the track
 111:     */
 112:    public short getVolume() {
 113:        return this.volume;
 114:    }
 115:
 116:    public void setVolume(short volume) {
 117:        this.volume = volume;
 118:    }
 119:
 120:    public Set getArtists() {
 121:        return this.artists;
 122:    }
 123:
 124:    public void setArtists(Set artists) {
 125:        this.artists = artists;
 126:    }
 127:
 128:    public Set getComments() {
 129:        return this.comments;
 130:    }
 131:
 132:    public void setComments(Set comments) {
 133:        this.comments = comments;
 134:    }
 135:
 136:    public String toString() {
 137:        return new ToStringBuilder(this)
 138:            .append("id", getId())
 139:            .append("title", getTitle())
 140:            .toString();
 141:    }
 142:
 143:}

   1:package com.oreilly.hh;
   2:
   3:import java.io.Serializable;
   4:import java.util.Set;
   5:import org.apache.commons.lang.builder.ToStringBuilder;
   6:
   7:
   8:/** 
   9: *       Represents an artist who is associated with a track or album.
  10: *       @author Jim Elliott (with help from Hibernate)
  11: *     
  12:*/
  13:public class Artist implements Serializable {
  14:
  15:    /** identifier field */
  16:    private Integer id;
  17:
  18:    /** nullable persistent field */
  19:    private String name;
  20:
  21:    /** persistent field */
  22:    private Set tracks;
  23:
  24:    /** full constructor */
  25:    public Artist(String name, Set tracks) {
  26:        this.name = name;
  27:        this.tracks = tracks;
  28:    }
  29:
  30:    /** default constructor */
  31:    public Artist() {
  32:    }
  33:
  34:    /** minimal constructor */
  35:    public Artist(Set tracks) {
  36:        this.tracks = tracks;
  37:    }
  38:
  39:    public Integer getId() {
  40:        return this.id;
  41:    }
  42:
  43:    protected void setId(Integer id) {
  44:        this.id = id;
  45:    }
  46:
  47:    public String getName() {
  48:        return this.name;
  49:    }
  50:
  51:    public void setName(String name) {
  52:        this.name = name;
  53:    }
  54:
  55:    /** 
  56:     * Tracks by this artist
  57:     */
  58:    public Set getTracks() {
  59:        return this.tracks;
  60:    }
  61:
  62:    public void setTracks(Set tracks) {
  63:        this.tracks = tracks;
  64:    }
  65:
  66:    public String toString() {
  67:        return new ToStringBuilder(this)
  68:            .append("id", getId())
  69:            .append("name", getName())
  70:            .toString();
  71:    }
  72:
  73:}

BUILD SUCCESSFUL
Total time: 7 seconds

mysql> show tables;
       +---------------------+
       | Tables_in_hibernate |
       +---------------------+
       | ARTIST |
       | TRACK |
       | TRACK_ARTISTS |
       | TRACK_COMMENTS |
       +---------------------+
       4 rows in set (0.00 sec)       

mysql> desc ARTIST;
         +-----------+--------------+------+-----+---------+----------------+
         | Field | Type | Null | Key | Default | Extra |
         +-----------+--------------+------+-----+---------+----------------+
         | ARTIST_ID | int(11) | | PRI | NULL | auto_increment |
         | NAME | varchar(255) | | UNI | | |
         +-----------+--------------+------+-----+---------+----------------+
         2 rows in set (0.00 sec)

mysql> desc TRACK;
         +----------+--------------+------+-----+---------+----------------+
         | Field | Type | Null | Key | Default | Extra |
         +----------+--------------+------+-----+---------+----------------+
         | TRACK_ID | int(11) | | PRI | NULL | auto_increment |
         | TITLE | varchar(255) | | MUL | | |
         | filePath | varchar(255) | | | | |
         | playTime | time | YES | | NULL | |
         | added | date | YES | | NULL | |
         | volume | smallint(6) | | | 0 | |
         +----------+--------------+------+-----+---------+----------------+
         6 rows in set (0.00 sec)

mysql> desc TRACK_ARTISTS;
         +-----------+---------+------+-----+---------+-------+
         | Field | Type | Null | Key | Default | Extra |
         +-----------+---------+------+-----+---------+-------+
         | ARTIST_ID | int(11) | | PRI | 0 | |
         | TRACK_ID | int(11) | | PRI | 0 | |
         +-----------+---------+------+-----+---------+-------+
         2 rows in set (0.00 sec)

mysql> desc TRACK_COMMENTS;
         +----------+--------------+------+-----+---------+-------+
         | Field | Type | Null | Key | Default | Extra |
         +----------+--------------+------+-----+---------+-------+
         | TRACK_ID | int(11) | | MUL | 0 | |
         | COMMENT | varchar(255) | YES | | NULL | |
         +----------+--------------+------+-----+---------+-------+
         2 rows in set (0.00 sec)

mysql> select * from ARTIST;
Empty set (0.00 sec)

mysql> select * from TRACK;
         Empty set (0.00 sec)

mysql> select * from TRACK_ARTISTS;
         Empty set (0.00 sec)

mysql> select * from TRACK_COMMENTS;
         Empty set (0.00 sec)
       

   1:package com.oreilly.hh;
   2:
   3:import net.sf.hibernate.*;
   4:import net.sf.hibernate.cfg.Configuration;
   5:
   6:import java.sql.Time;
   7:import java.util.*;
   8:
   9:/**
  10: * Create more sample data, letting Hibernate persist it for us.
  11: */
  12:public class CreateTest {
  13:
  14:    /**
  15:     * Look up an artist record given a name.
  16:     * @param name the name of the artist desired.
  17:     * @param create controls whether a new record should be created if
  18:     *        the specified artist is not yet in the database.
  19:     * @param session the Hibernate session that can retrieve data
  20:     * @return the artist with the specified name, or <code>null</code> if no
  21:     *         such artist exists and <code>create</code> is <code>false</code>.
  22:     * @throws HibernateException if there is a problem.
  23:     */
  24:    public static Artist getArtist(String name, boolean create,
  25:                                    Session session)
  26:        throws HibernateException
  27:    {
  28:        Query query = session.getNamedQuery(
  29:                          "com.oreilly.hh.artistByName");
  30:        query.setString("name", name);
  31:        Artist found = (Artist)query.uniqueResult();
  32:        if (found == null && create) {
  33:            found = new Artist(name, new HashSet());
  34:            session.save(found);
  35:        }
  36:        return found;
  37:    }
  38:
  39:    /**
  40:     * Utility method to associate an artist with a track
  41:     */
  42:    private static void addTrackArtist(Track track, Artist artist) {
  43:        track.getArtists().add(artist);
  44:    }
  45:
  46:    public static void main(String args[]) throws Exception {
  47:        // Create a configuration based on the properties file we've put
  48:        // in the standard place.
  49:        Configuration config = new Configuration();
  50:
  51:        // Tell it about the classes we want mapped, taking advantage of
  52:        // the way we've named their mapping documents.
  53:        config.addClass(Track.class).addClass(Artist.class);
  54:
  55:        // Get the session factory we can use for persistence
  56:        SessionFactory sessionFactory = config.buildSessionFactory();
  57:
  58:        // Ask for a session using the JDBC information we've configured
  59:        Session session = sessionFactory.openSession();
  60:        Transaction tx = null;
  61:        try {
  62:            // Create some data and persist it
  63:            tx = session.beginTransaction();
  64:
  65:            Track track = new Track("Russian Trance",
  66:                                    "vol2/album610/track02.mp3",
  67:                                    Time.valueOf("00:03:30"), new Date(),
  68:                                    (short)0, new HashSet(), new HashSet());
  69:            addTrackArtist(track, getArtist("PPK", true, session));
  70:            session.save(track);
  71:
  72:            track = new Track("Video Killed the Radio Star",
  73:                              "vol2/album611/track12.mp3",
  74:                              Time.valueOf("00:03:49"), new Date(),
  75:                              (short)0, new HashSet(), new HashSet());
  76:            addTrackArtist(track, getArtist("The Buggles", true, session));
  77:            session.save(track);
  78:
  79:            
  80:            track = new Track("Gravity's Angel",
  81:                              "vol2/album175/track03.mp3",
  82:                              Time.valueOf("00:06:06"), new Date(),
  83:                              (short)0, new HashSet(), new HashSet());
  84:            addTrackArtist(track, getArtist("Laurie Anderson", true, session));
  85:            session.save(track);
  86:
  87:            track = new Track("Adagio for Strings (Ferry Corsten Remix)",
  88:                              "vol2/album972/track01.mp3",
  89:                              Time.valueOf("00:06:35"), new Date(),
  90:                              (short)0, new HashSet(), new HashSet());
  91:            addTrackArtist(track, getArtist("William Orbit", true, session));
  92:            addTrackArtist(track, getArtist("Ferry Corsten", true, session));
  93:            addTrackArtist(track, getArtist("Samuel Barber", true, session));
  94:            session.save(track);
  95:
  96:            track = new Track("Adagio for Strings (ATB Remix)",
  97:                              "vol2/album972/track02.mp3",
  98:                              Time.valueOf("00:07:39"), new Date(),
  99:                              (short)0, new HashSet(), new HashSet());
 100:            addTrackArtist(track, getArtist("William Orbit", true, session));
 101:            addTrackArtist(track, getArtist("ATB", true, session));
 102:            addTrackArtist(track, getArtist("Samuel Barber", true, session));
 103:            session.save(track);
 104:
 105:            track = new Track("The World '99",
 106:                              "vol2/singles/pvw99.mp3",
 107:                              Time.valueOf("00:07:05"), new Date(),
 108:                              (short)0, new HashSet(), new HashSet());
 109:            addTrackArtist(track, getArtist("Pulp Victim", true, session));
 110:            addTrackArtist(track, getArtist("Ferry Corsten", true, session));
 111:            session.save(track);
 112:
 113:            track = new Track("Test Tone 1",
 114:                              "vol2/singles/test01.mp3",
 115:                              Time.valueOf("00:00:10"), new Date(),
 116:                              (short)0, new HashSet(), new HashSet());
 117:            track.getComments().add("Pink noise to test equalization");
 118:            session.save(track);
 119:
 120:            // We're done; make our changes permanent
 121:            tx.commit();
 122:
 123:        } catch (Exception e) {
 124:            if (tx != null) {
 125:                // Something went wrong; discard all partial changes
 126:                tx.rollback();
 127:            }
 128:            throw e;
 129:        } finally {
 130:            // No matter what, close the session
 131:            session.close();
 132:        }
 133:
 134:        // Clean up after ourselves
 135:        sessionFactory.close();
 136:    }
 137:}

BUILD SUCCESSFUL
Total time: 6 seconds

mysql> select * from ARTIST;
       +-----------+-----------------+
       | ARTIST_ID | NAME |
       +-----------+-----------------+
       | 1 | PPK |
       | 2 | The Buggles |
       | 3 | Laurie Anderson |
       | 4 | William Orbit |
       | 5 | Ferry Corsten |
       | 6 | Samuel Barber |
       | 7 | ATB |
       | 8 | Pulp Victim |
       +-----------+-----------------+
       8 rows in set (0.00 sec)       

mysql> select * from TRACK;
         +----------+------------------------------------------+---------------------------+----------+------------+--------+
         | TRACK_ID | TITLE | filePath | playTime | added | volume |
         +----------+------------------------------------------+---------------------------+----------+------------+--------+
         | 1 | Russian Trance | vol2/album610/track02.mp3 | 00:03:30 | 2005-02-15          | 0 |
         | 2 | Video Killed the Radio Star | vol2/album611/track12.mp3 | 00:03:49          | 2005-02-15 | 0 |
         | 3 | Gravity's Angel | vol2/album175/track03.mp3 | 00:06:06 | 2005-02-15          | 0 |
         | 4 | Adagio for Strings (Ferry Corsten Remix) | vol2/album972/track01.mp3          | 00:06:35 | 2005-02-15 | 0 |
         | 5 | Adagio for Strings (ATB Remix) | vol2/album972/track02.mp3 | 00:07:39          | 2005-02-15 | 0 |
         | 6 | The World '99 | vol2/singles/pvw99.mp3 | 00:07:05 | 2005-02-15 |          0 |
         | 7 | Test Tone 1 | vol2/singles/test01.mp3 | 00:00:10 | 2005-02-15 |          0 |
         +----------+------------------------------------------+---------------------------+----------+------------+--------+
         7 rows in set (0.00 sec)

mysql> select * from TRACK_ARTISTS;
         +-----------+----------+
         | ARTIST_ID | TRACK_ID |
         +-----------+----------+
         | 1 | 1 |
         | 2 | 2 |
         | 3 | 3 |
         | 4 | 4 |
         | 5 | 4 |
         | 6 | 4 |
         | 4 | 5 |
         | 6 | 5 |
         | 7 | 5 |
         | 5 | 6 |
         | 8 | 6 |
         +-----------+----------+
         11 rows in set (0.00 sec)

mysql> select * from TRACK_COMMENTS;
         +----------+---------------------------------+
         | TRACK_ID | COMMENT |
         +----------+---------------------------------+
         | 7 | Pink noise to test equalization |
         +----------+---------------------------------+
         1 row in set (0.00 sec)
       

   1:package com.oreilly.hh;
   2:
   3:import net.sf.hibernate.*;
   4:import net.sf.hibernate.cfg.Configuration;
   5:
   6:import java.sql.Time;
   7:import java.util.*;
   8:
   9:/**
  10: * Retrieve data as objects
  11: */
  12:public class QueryTest {
  13:
  14:    /**
  15:     * Retrieve any tracks that fit in the specified amount of time.
  16:     *
  17:     * @param length the maximum playing time for tracks to be returned.
  18:     * @param session the Hibernate session that can retrieve data.
  19:     * @return a list of {@link Track}s meeting the length restriction.
  20:     * @throws HibernateException if there is a problem.
  21:     */
  22:    public static List tracksNoLongerThan(Time length, Session session)
  23:        throws HibernateException
  24:    {
  25:        Query query = session.getNamedQuery(
  26:                          "com.oreilly.hh.tracksNoLongerThan");
  27:        query.setTime("length", length);
  28:        return query.list();
  29:    }   
  30:
  31:    /**
  32:     * Build a parenthetical, comma-separated list of artist names.
  33:     * @param artists the artists whose names are to be displayed.
  34:     * @return formatted list, or an empty string if the set was empty.
  35:     */
  36:    public static String listArtistNames(Set artists) {
  37:        StringBuffer result = new StringBuffer();
  38:        for (Iterator iter = artists.iterator(); iter.hasNext(); ) {
  39:            Artist artist = (Artist)iter.next();
  40:            result.append((result.length() == 0) ? "(" : ", ");
  41:            result.append(artist.getName());
  42:        }
  43:        if (result.length() > 0) {
  44:            result.append(") ");
  45:        }
  46:        return result.toString();
  47:    }
  48:
  49:    /**
  50:     * Look up and print some tracks when invoked from the command line.
  51:     */
  52:    public static void main(String args[]) throws Exception {
  53:        // Create a configuration based on the properties file we've put
  54:        // in the standard place.
  55:        Configuration config = new Configuration();
  56:
  57:        // Tell it about the classes we want mapped, taking advantage of
  58:        // the way we've named their mapping documents.
  59:        config.addClass(Track.class).addClass(Artist.class);
  60:
  61:        // Get the session factory we can use for persistence
  62:        SessionFactory sessionFactory = config.buildSessionFactory();
  63:
  64:        // Ask for a session using the JDBC information we've configured
  65:        Session session = sessionFactory.openSession();
  66:        try {
  67:            // Print the tracks that will fit in seven minutes
  68:            List tracks = tracksNoLongerThan(Time.valueOf("00:07:00"),
  69:                                             session);
  70:            for (ListIterator iter = tracks.listIterator() ;
  71:                 iter.hasNext() ; ) {
  72:                Track aTrack = (Track)iter.next();
  73:                System.out.println("Track: \"" + aTrack.getTitle() + "\" " +
  74:                                   listArtistNames(aTrack.getArtists()) +
  75:                                   aTrack.getPlayTime());
  76:                for (Iterator comIter = aTrack.getComments().iterator() ;
  77:                     comIter.hasNext() ; ) {
  78:                    System.out.println("  Comment: " + comIter.next());
  79:                }
  80:            }
  81:        } finally {
  82:            // No matter what, close the session
  83:            session.close();
  84:        }
  85:
  86:        // Clean up after ourselves
  87:        sessionFactory.close();
  88:    }
  89:}

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Track" table="TRACK">
   8:    <meta attribute="class-description">
   9:      Represents a single playable track in the music database.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="TRACK_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="title" type="string">
  19:      <meta attribute="use-in-tostring">true</meta>
  20:      <column name="TITLE" not-null="true" index="TRACK_TITLE"/>
  21:    </property>
  22:
  23:    <property name="filePath" type="string" not-null="true"/>
  24:
  25:    <property name="playTime" type="time">
  26:      <meta attribute="field-description">Playing time</meta>
  27:    </property>
  28:
  29:    <set name="artists" table="TRACK_ARTISTS">
  30:      <key column="TRACK_ID"/>
  31:      <many-to-many class="com.oreilly.hh.Artist" column="ARTIST_ID"/>
  32:    </set>
  33:
  34:    <set name="comments" table="TRACK_COMMENTS">
  35:      <key column="TRACK_ID"/>
  36:      <element column="COMMENT" type="string"/>
  37:    </set>
  38:
  39:    <property name="added" type="date">
  40:      <meta attribute="field-description">When the track was created</meta>
  41:    </property>
  42:
  43:    <property name="volume" type="short" not-null="true">
  44:      <meta attribute="field-description">How loud to play the track</meta>
  45:    </property>
  46:
  47:  </class>
  48:
  49:  <query name="com.oreilly.hh.tracksNoLongerThan">
  50:    <![CDATA[
  51:        from com.oreilly.hh.Track as track
  52:        where track.playTime <= :length
  53:      ]]>
  54:  </query>
  55:
  56:</hibernate-mapping>

   1:<?xml version="1.0"?>
   2:<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
   3:          "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
   4:
   5:<hibernate-mapping>
   6:
   7:  <class name="com.oreilly.hh.Artist" table="ARTIST">
   8:    <meta attribute="class-description">
   9:      Represents an artist who is associated with a track or album.
  10:      @author Jim Elliott (with help from Hibernate)
  11:    </meta>
  12:
  13:    <id name="id" type="int" column="ARTIST_ID">
  14:      <meta attribute="scope-set">protected</meta>
  15:      <generator class="native"/>
  16:    </id>
  17:
  18:    <property name="name" type="string">
  19:      <meta attribute="use-in-tostring">true</meta>
  20:      <column name="NAME" not-null="true" unique="true" index="ARTIST_NAME"/>
  21:    </property>
  22:
  23:    <set name="tracks" table="TRACK_ARTISTS" inverse="true">
  24:      <meta attribute="field-description">Tracks by this artist</meta>
  25:      <key column="ARTIST_ID"/>
  26:      <many-to-many class="com.oreilly.hh.Track" column="TRACK_ID"/>
  27:    </set>
  28:
  29:    <many-to-one name="actualArtist" class="com.oreilly.hh.Artist">
  30:      <meta attribute="use-in-tostring">true</meta>
  31:    </many-to-one>
  32:
  33:  </class>
  34:
  35:  <query name="com.oreilly.hh.artistByName">
  36:    <![CDATA[
  37:        from com.oreilly.hh.Artist as artist
  38:        where upper(artist.name) = upper(:name)
  39:      ]]>
  40:  </query>
  41:
  42:</hibernate-mapping>