Rename artifact and folder.

service-layer/src/main/java/com/iluwatar/App.java

@@ -0,0 +1,117 @@
+package com.iluwatar;
+
+
+/**
+ * 
+ * 
+ *
+ */
+public class App {
+	
+    public static void main( String[] args ) {   
+    	initData();
+    	queryData();
+    }
+    
+    public static void initData() {
+    	Spell spell1 = new Spell("Ice dart");
+    	Spell spell2 = new Spell("Invisibility");
+    	Spell spell3 = new Spell("Stun bolt");
+    	Spell spell4 = new Spell("Confusion");
+    	Spell spell5 = new Spell("Darkness");
+    	Spell spell6 = new Spell("Fireball");
+    	Spell spell7 = new Spell("Enchant weapon");
+    	Spell spell8 = new Spell("Rock armour");
+    	Spell spell9 = new Spell("Light");
+    	Spell spell10 = new Spell("Bee swarm");
+    	Spell spell11 = new Spell("Haste");
+    	Spell spell12 = new Spell("Levitation");
+    	Spell spell13 = new Spell("Magic lock");
+    	Spell spell14 = new Spell("Summon hell bat");
+    	Spell spell15 = new Spell("Water walking");
+    	Spell spell16 = new Spell("Magic storm");
+    	Spell spell17 = new Spell("Entangle");
+    	SpellDao spellDao = new SpellDaoImpl();
+    	spellDao.persist(spell1);
+    	spellDao.persist(spell2);
+    	spellDao.persist(spell3);
+    	spellDao.persist(spell4);
+    	spellDao.persist(spell5);
+    	spellDao.persist(spell6);
+    	spellDao.persist(spell7);
+    	spellDao.persist(spell8);
+    	spellDao.persist(spell9);
+    	spellDao.persist(spell10);
+    	spellDao.persist(spell11);
+    	spellDao.persist(spell12);
+    	spellDao.persist(spell13);
+    	spellDao.persist(spell14);
+    	spellDao.persist(spell15);
+    	spellDao.persist(spell16);
+    	spellDao.persist(spell17);
+    	
+    	SpellbookDao spellbookDao = new SpellbookDaoImpl();
+    	Spellbook spellbook1 = new Spellbook("Book of Orgymon");
+    	spellbookDao.persist(spellbook1);
+    	spellbook1.addSpell(spell1);
+    	spellbook1.addSpell(spell2);
+    	spellbook1.addSpell(spell3);    	
+    	spellbook1.addSpell(spell4);    
+    	spellbookDao.merge(spellbook1);
+    	Spellbook spellbook2 = new Spellbook("Book of Aras");
+    	spellbookDao.persist(spellbook2);
+    	spellbook2.addSpell(spell5);
+    	spellbook2.addSpell(spell6);    	
+    	spellbookDao.merge(spellbook2);
+    	Spellbook spellbook3 = new Spellbook("Book of Kritior");
+    	spellbookDao.persist(spellbook3);
+    	spellbook3.addSpell(spell7);
+    	spellbook3.addSpell(spell8);
+    	spellbook3.addSpell(spell9);    	
+    	spellbookDao.merge(spellbook3);
+    	Spellbook spellbook4 = new Spellbook("Book of Tamaex");
+    	spellbookDao.persist(spellbook4);
+    	spellbook4.addSpell(spell10);
+    	spellbook4.addSpell(spell11);
+    	spellbook4.addSpell(spell12);    	
+    	spellbookDao.merge(spellbook4);
+    	Spellbook spellbook5 = new Spellbook("Book of Idores");
+    	spellbookDao.persist(spellbook5);
+    	spellbook5.addSpell(spell13);
+    	spellbookDao.merge(spellbook5);
+    	Spellbook spellbook6 = new Spellbook("Book of Opaen");
+    	spellbookDao.persist(spellbook6);
+    	spellbook6.addSpell(spell14);
+    	spellbook6.addSpell(spell15);    	
+    	spellbookDao.merge(spellbook6);
+    	Spellbook spellbook7 = new Spellbook("Book of Kihione");
+    	spellbookDao.persist(spellbook7);
+    	spellbook7.addSpell(spell16);
+    	spellbook7.addSpell(spell17);
+    	spellbookDao.merge(spellbook7);
+    	
+    	WizardDao wizardDao = new WizardDaoImpl();
+    	Wizard wizard1 = new Wizard("Aderlard Boud");
+    	wizardDao.persist(wizard1);
+    	wizard1.addSpellbook(spellbookDao.findByName("Book of Orgymon"));
+    	wizard1.addSpellbook(spellbookDao.findByName("Book of Aras"));
+    	wizardDao.merge(wizard1);
+    	Wizard wizard2 = new Wizard("Anaxis Bajraktari");
+    	wizardDao.persist(wizard2);
+    	wizard2.addSpellbook(spellbookDao.findByName("Book of Kritior"));
+    	wizard2.addSpellbook(spellbookDao.findByName("Book of Tamaex"));
+    	wizardDao.merge(wizard2);
+    	Wizard wizard3 = new Wizard("Xuban Munoa");
+    	wizardDao.persist(wizard3);
+    	wizard3.addSpellbook(spellbookDao.findByName("Book of Idores"));
+    	wizard3.addSpellbook(spellbookDao.findByName("Book of Opaen"));
+    	wizardDao.merge(wizard3);
+    	Wizard wizard4 = new Wizard("Blasius Dehooge");
+    	wizardDao.persist(wizard4);
+    	wizard4.addSpellbook(spellbookDao.findByName("Book of Kihione"));
+    	wizardDao.merge(wizard4);
+    }
+    
+    public static void queryData() {
+    }
+}

service-layer/src/main/java/com/iluwatar/BaseEntity.java

@@ -0,0 +1,14 @@
+package com.iluwatar;
+
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.MappedSuperclass;
+import javax.persistence.Version;
+
+@MappedSuperclass
+@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
+public class BaseEntity {
+	
+	@Version
+	private Long version;
+}

service-layer/src/main/java/com/iluwatar/Dao.java

@@ -0,0 +1,16 @@
+package com.iluwatar;
+
+import java.util.List;
+
+public interface Dao<E extends BaseEntity> {
+
+	E find(Long id);
+	
+	void persist(E entity);
+	
+	E merge(E entity);
+	
+	void delete(E entity);
+	
+	List<E> findAll();
+}

service-layer/src/main/java/com/iluwatar/DaoBaseImpl.java

@@ -0,0 +1,118 @@
+package com.iluwatar;
+
+import java.lang.reflect.ParameterizedType;
+import java.util.List;
+
+import org.hibernate.Criteria;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.hibernate.criterion.Restrictions;
+
+public abstract class DaoBaseImpl<E extends BaseEntity> implements Dao<E> {
+	
+	@SuppressWarnings("unchecked")
+	protected Class<E> persistentClass = (Class<E>) ((ParameterizedType) getClass()
+            .getGenericSuperclass()).getActualTypeArguments()[0];
+
+	protected Session getSession() {
+		return HibernateUtil.getSessionFactory().openSession();
+	}
+	
+	@Override
+	public E find(Long id) {
+		Session session = getSession();
+		Transaction tx = null;
+		E result = null;
+		try {
+			tx = session.beginTransaction();
+			Criteria criteria = session.createCriteria(persistentClass);
+			criteria.add(Restrictions.idEq(id));
+			result = (E) criteria.uniqueResult();
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+	
+	@Override
+	public void persist(E entity) {
+		Session session = getSession();
+		Transaction tx = null;
+		try {
+			tx = session.beginTransaction();
+			session.persist(entity);
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+	}
+	
+	@Override
+	public E merge(E entity) {
+		Session session = getSession();
+		Transaction tx = null;
+		E result = null;
+		try {
+			tx = session.beginTransaction();
+			result = (E) session.merge(entity);
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+	
+	@Override
+	public void delete(E entity) {
+		Session session = getSession();
+		Transaction tx = null;
+		try {
+			tx = session.beginTransaction();
+			session.delete(entity);
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+	}
+	
+	@Override
+	public List<E> findAll() {
+		Session session = getSession();
+		Transaction tx = null;
+		List<E> result = null;
+		try {
+			tx = session.beginTransaction();
+			Criteria criteria = session.createCriteria(persistentClass);
+			result = criteria.list();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+}

service-layer/src/main/java/com/iluwatar/HibernateUtil.java

@@ -0,0 +1,31 @@
+package com.iluwatar;
+
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateUtil {
+
+	private static final SessionFactory sessionFactory;
+
+	static {
+		try {
+	    	sessionFactory = new Configuration()
+	  	  		.addAnnotatedClass(Wizard.class)
+	  	  		.addAnnotatedClass(Spellbook.class)
+	  	  		.addAnnotatedClass(Spell.class)
+	  	  		.setProperty("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
+	  	  		.setProperty("hibernate.connection.url", "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1")
+	  	  		.setProperty("hibernate.current_session_context_class", "thread")
+	  	  		.setProperty("hibernate.show_sql", "true")
+	  	  		.setProperty("hibernate.hbm2ddl.auto", "create-drop")
+	  	  		.buildSessionFactory();
+		} catch (Throwable ex) {
+			System.err.println("Initial SessionFactory creation failed." + ex);
+			throw new ExceptionInInitializerError(ex);
+		}
+	}
+
+	public static SessionFactory getSessionFactory() {
+		return sessionFactory;
+	}
+}

service-layer/src/main/java/com/iluwatar/MagicService.java

@@ -0,0 +1,6 @@
+package com.iluwatar;
+
+
+public interface MagicService {
+	
+}

service-layer/src/main/java/com/iluwatar/MagicServiceImpl.java

@@ -0,0 +1,5 @@
+package com.iluwatar;
+
+public class MagicServiceImpl implements MagicService {
+
+}

service-layer/src/main/java/com/iluwatar/Spell.java

@@ -0,0 +1,62 @@
+package com.iluwatar;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+
+@Entity
+@Table(name="SPELL")
+public class Spell extends BaseEntity {
+	
+	private String name;
+	
+	public Spell() {
+	}
+	
+	public Spell(String name) {
+		this();
+		this.name = name;
+	}
+
+	@Id
+	@GeneratedValue
+	@Column(name = "SPELL_ID")
+	private Long id;
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	
+	@ManyToOne
+	@JoinColumn(name="SPELLBOOK_ID_FK", referencedColumnName="SPELLBOOK_ID")
+	private Spellbook spellbook;
+	
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	public Spellbook getSpellbook() {
+		return spellbook;
+	}
+
+	public void setSpellbook(Spellbook spellbook) {
+		this.spellbook = spellbook;
+	}
+
+	@Override
+	public String toString() {
+		return name;
+	}	
+}

service-layer/src/main/java/com/iluwatar/SpellDao.java

@@ -0,0 +1,7 @@
+package com.iluwatar;
+
+public interface SpellDao extends Dao<Spell> {
+	
+	Spell findByName(String name);
+
+}

service-layer/src/main/java/com/iluwatar/SpellDaoImpl.java

@@ -0,0 +1,31 @@
+package com.iluwatar;
+
+import org.hibernate.Criteria;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.hibernate.criterion.Expression;
+
+public class SpellDaoImpl extends DaoBaseImpl<Spell> implements SpellDao {
+
+	@Override
+	public Spell findByName(String name) {
+		Session session = getSession();
+		Transaction tx = null;
+		Spell result = null;
+		try {
+			tx = session.beginTransaction();
+			Criteria criteria = session.createCriteria(persistentClass);
+			criteria.add(Expression.eq("name", name));
+			result = (Spell) criteria.uniqueResult();
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+}

service-layer/src/main/java/com/iluwatar/Spellbook.java

@@ -0,0 +1,83 @@
+package com.iluwatar;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.ManyToMany;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+
+@Entity
+@Table(name="SPELLBOOK")
+public class Spellbook extends BaseEntity {
+	
+	public Spellbook() {
+		spells = new HashSet<Spell>();
+		wizards = new HashSet<Wizard>();
+	}
+	
+	public Spellbook(String name) {
+		this();
+		this.name = name;
+	}
+
+	@Id
+	@GeneratedValue
+	@Column(name = "SPELLBOOK_ID")
+	private Long id;
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	
+	private String name;
+
+	@ManyToMany(mappedBy = "spellbooks")
+	private Set<Wizard> wizards;
+
+	@OneToMany(mappedBy = "spellbook", orphanRemoval = true, cascade = CascadeType.ALL)
+	private Set<Spell> spells;
+	
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public Set<Wizard> getWizards() {
+		return wizards;
+	}
+
+	public void setWizards(Set<Wizard> wizards) {
+		this.wizards = wizards;
+	}
+
+	public Set<Spell> getSpells() {
+		return spells;
+	}
+
+	public void setSpells(Set<Spell> spells) {
+		this.spells = spells;
+	}
+
+	public void addSpell(Spell spell) {
+		spell.setSpellbook(this);
+		spells.add(spell);
+	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}	
+}

service-layer/src/main/java/com/iluwatar/SpellbookDao.java

@@ -0,0 +1,7 @@
+package com.iluwatar;
+
+public interface SpellbookDao extends Dao<Spellbook> {
+	
+	Spellbook findByName(String name);
+
+}

service-layer/src/main/java/com/iluwatar/SpellbookDaoImpl.java

@@ -0,0 +1,34 @@
+package com.iluwatar;
+
+import org.hibernate.Criteria;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.hibernate.criterion.Expression;
+
+public class SpellbookDaoImpl extends DaoBaseImpl<Spellbook> implements SpellbookDao {
+
+	@Override
+	public Spellbook findByName(String name) {
+		Session session = getSession();
+		Transaction tx = null;
+		Spellbook result = null;
+		try {
+			tx = session.beginTransaction();
+			Criteria criteria = session.createCriteria(persistentClass);
+			criteria.add(Expression.eq("name", name));
+			result = (Spellbook) criteria.uniqueResult();
+			result.getSpells().size();
+			result.getWizards().size();
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+
+}

service-layer/src/main/java/com/iluwatar/Wizard.java

@@ -0,0 +1,70 @@
+package com.iluwatar;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.ManyToMany;
+import javax.persistence.Table;
+
+@Entity
+@Table(name="WIZARD")
+public class Wizard extends BaseEntity {
+	
+	public Wizard() {
+		spellbooks = new HashSet<Spellbook>();
+	}
+	
+	public Wizard(String name) {
+		this();
+		this.name = name;
+	}
+
+	@Id
+	@GeneratedValue
+	@Column(name = "WIZARD_ID")
+	private Long id;
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	
+	private String name;
+
+	@ManyToMany(cascade = CascadeType.ALL)
+	private Set<Spellbook> spellbooks;
+	
+	public String getFirstName() {
+		return name;
+	}
+
+	public void setFirstName(String firstName) {
+		this.name = firstName;
+	}
+
+	public Set<Spellbook> getSpellbooks() {
+		return spellbooks;
+	}
+
+	public void setSpellbooks(Set<Spellbook> spellbooks) {
+		this.spellbooks = spellbooks;
+	}
+
+	public void addSpellbook(Spellbook spellbook) {
+		spellbook.getWizards().add(this);
+		spellbooks.add(spellbook);
+	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}	
+}

service-layer/src/main/java/com/iluwatar/WizardDao.java

@@ -0,0 +1,7 @@
+package com.iluwatar;
+
+public interface WizardDao extends Dao<Wizard> {
+	
+	Wizard findByName(String name);
+
+}

service-layer/src/main/java/com/iluwatar/WizardDaoImpl.java

@@ -0,0 +1,32 @@
+package com.iluwatar;
+
+import org.hibernate.Criteria;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.hibernate.criterion.Expression;
+
+public class WizardDaoImpl extends DaoBaseImpl<Wizard> implements WizardDao {
+
+	@Override
+	public Wizard findByName(String name) {
+		Session session = getSession();
+		Transaction tx = null;
+		Wizard result = null;
+		try {
+			tx = session.beginTransaction();
+			Criteria criteria = session.createCriteria(persistentClass);
+			criteria.add(Expression.eq("name", name));
+			result = (Wizard) criteria.uniqueResult();
+			result.getSpellbooks().size();
+			tx.commit();
+		}
+		catch (Exception e) {
+			if (tx!=null) tx.rollback();
+			throw e;
+		}
+		finally {
+			session.close();
+		}		
+		return result;
+	}
+}

service-layer/src/test/java/com/iluwatar/AppTest.java

@@ -0,0 +1,4 @@
+package com.iluwatar;
+
+public class AppTest {
+}