Inserir Coleção Hibernate

abstract class GenericDAO<T> implements Serializable {
	private static final long serialVersionUID = 1L;

	private static final EntityManagerFactory emf = Persistence.createEntityManagerFactory("JSFCrudPU");
	private EntityManager em;

	private Class<T> entityClass;

	public void beginTransaction() {
		em = emf.createEntityManager();

		em.getTransaction().begin();
	}

	public void commit() {
		em.getTransaction().commit();
	}

	public void rollback() {
		em.getTransaction().rollback();
	}

	public void closeTransaction() {
		em.close();
	}

	public void commitAndCloseTransaction() {
		commit();
		closeTransaction();
	}

	public void flush() {
		em.flush();
	}

	public void joinTransaction() {
		em = emf.createEntityManager();
		em.joinTransaction();
	}

	public GenericDAO(Class<T> entityClass) {
		this.entityClass = entityClass;
	}

	public void save(T entity) {
		em.persist(entity);
	}

	public void delete(T entity) {
		T entityToBeRemoved = em.merge(entity);

		em.remove(entityToBeRemoved);
	}

	public T update(T entity) {
		return em.merge(entity);
	}

	public T find(int entityID) {
		return em.find(entityClass, entityID);
	}

	public T findReferenceOnly(int entityID) {
		return em.getReference(entityClass, entityID);
	}

	// Using the unchecked because JPA does not have a
	// em.getCriteriaBuilder().createQuery()<T> method
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public List<T> findAll() {
		CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
		cq.select(cq.from(entityClass));
		return em.createQuery(cq).getResultList();
	}

	// Using the unchecked because JPA does not have a
	// query.getSingleResult()<T> method
	@SuppressWarnings("unchecked")
	protected T findOneResult(String namedQuery, Map<String, Object> parameters) {
		T result = null;

		try {
			Query query = em.createNamedQuery(namedQuery);

			// Method that will populate parameters if they are passed not null and empty
			if (parameters != null && !parameters.isEmpty()) {
				populateQueryParameters(query, parameters);
			}

			result = (T) query.getSingleResult();

		} catch (NoResultException e) {
			System.out.println("No result found for named query: " + namedQuery);
		} catch (Exception e) {
			System.out.println("Error while running query: " + e.getMessage());
			e.printStackTrace();
		}

		return result;
	}

	private void populateQueryParameters(Query query, Map<String, Object> parameters) {
		for (Entry<String, Object> entry : parameters.entrySet()) {
			query.setParameter(entry.getKey(), entry.getValue());
		}
	}
}

package Utilitarios;
 
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
 
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;
 
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import Model.Cliente;
 
/**
 * @author SAMUEL FACCHINELLO
 * @version 1.0
 */


public class GenericDao {


    
    public static List executeHQLList(String hql){
        Session em = HibernateUtil.getSessionFactory().openSession();
        Query query = em.createQuery(hql);
        List<Object> lista = query.list();
        em.clear();
        em.close();
        return lista;
    }
    
     public static List findSpecify(Object classe, String column, Object content) {
	Session em = HibernateUtil.getSessionFactory().openSession();
        Query query = em.createQuery("Select c from " + classe.getClass().getName() + " c where " + column + " Like '%" + content + "%'");
        List<Object> lista = query.list();
        em.clear();
        em.close();
        return lista;
       }
     
     public static List findByNamedQuery(Object classe, String namedQuery, String column, Object value) {
	Session em = HibernateUtil.getSessionFactory().openSession();
        Query query = em.getNamedQuery(namedQuery).setParameter(column, value);
        List<Object> lista = query.list();
        em.clear();
        em.close();
        return lista;
       }
     
 /**
  * Salva ou Atualiza dependendo se j&#65533; existe ou n&#65533;o o objeto no banco de dados. 
  * @param o: Entidade a ser Salva (se ainda n&#65533;o existir) ou a ser Atualizada (se j&#65533; existir)
  * @return Retorna a Entidade passada como par&#65533;metro.
  * @throws Exception
  */
 public Object saveOrUpdate(Object o) throws Exception {
	 System.out.println("Veio no save or update");
  Session em = HibernateUtil.getSessionFactory().openSession();
  Transaction trans = em.beginTransaction();
  try {
   em.merge(o);
   trans.commit();
   return o;
  } catch (Exception e) {
   if (trans.isActive()) {
    trans.rollback();
   }
   e.printStackTrace();
   throw e;
  } finally {
   em.close();
  }
 }
 
 /**
  * Salva ou Atualiza dependendo se j&#65533; existe ou n&#65533;o o objeto no banco de dados. 
  * @param list: lista das Entidades a serem Salvas (se ainda n&#65533;o existir) ou a serem Atualizadas (se j&#65533; existir)
  * @return Retorna a Entidade passada como par&#65533;metro.
  * @throws Exception
  */
 public void saveOrUpdateAll(ArrayList<Object> list) throws Exception {
	  Session em = HibernateUtil.getSessionFactory().openSession();
  Transaction trans = em.beginTransaction();
  try {
   trans.begin();
   for (Object o : list) {
    em.merge(o);
   }
   trans.commit();
  } catch (Exception e) {
   if (trans.isActive()) {
    trans.rollback();
   }
   e.printStackTrace();
   throw e;
  } finally {
   em.close();
  }
 }
 
 /**
  * Remove a Entidade do banco de dados.
  * @param o: Entidade a ser removido do banco de dados.
  * @throws Exception
  */
 public void remove(Object o) throws Exception {
	  Session em = HibernateUtil.getSessionFactory().openSession();
  Transaction trans = em.beginTransaction();
  try {
   em.delete(o);
   trans.commit();
  } catch (Exception e) {
   if (trans.isActive()) {
    trans.rollback();
   }
   throw e;
  } finally {
   em.close();
  }
 }
 
 /**
  * Remove a Entidade do banco de dados.
  * @param list: Lista de Entidades a serem removidas do banco de dados.
  * @throws Exception
  */
 public void removeAll(ArrayList<Object> list) throws Exception {
	  Session em = HibernateUtil.getSessionFactory().openSession();
  Transaction trans = em.beginTransaction();
  try {
   trans.begin();
   for (Object o : list) {
    em.delete(o);
   }
   trans.commit();
  } catch (Exception e) {
   if (trans.isActive()) {
    trans.rollback();
   }
   throw e;
  } finally {
   em.close();
  }
 }
 
 /**
  * Retorna a lista de itens salvo no banco de dados de acordo com a Entidade passada como par&#65533;metro.
  * @param classe : Entidade que dever&#65533; buscar no banco de dados.
  * @return List contendo todos os objetos encontrados da entidade passada como par&#65533;metro.
  */
 public static List findAll(Object classe) {
	  Session em = HibernateUtil.getSessionFactory().openSession();
          
          Query query = em.createQuery("Select a from " + classe.getClass().getName() + " a");
          List<Object> lista = query.list();
          em.clear();
          em.close();
          return lista;
 }
 
 /**
  * Faz a busca no banco pelo ID da entidade
  * @param classe : Entidade a ser buscada
  * @param id : valor a ser procurado
  * @return Objeto encontrado no banco, caso n&#65533;o encontre ser&#65533; retornado NULL
  * @throws Exception
  */
 @SuppressWarnings("unchecked")
 public static Object findById(Class classe, Object id) throws Exception {
  if (classe == null) {
   throw new Exception("classe n&#65533;o pode ser nula.");
  }
 
  if (id == null) {
   throw new Exception("id n&#65533;o pode ser nulo.");
  }
 
  Field[] fields = classe.getDeclaredFields();
  String chave = "";
  for (Field field : fields) {
   if (field.getAnnotation(Id.class) != null) {
    chave = field.getName();
    break;
   }
  }
 
  if (chave.equals("")) {
   throw new Exception("Annotation @Id n&#65533;o encontrada na classe " + classe.getName());
  }
 
  Session em = HibernateUtil.getSessionFactory().openSession();
  Query query = em.createQuery("Select a from " + classe.getName() + " a" +
          " where a." + chave + " = :id").setParameter("id", id);
  query.setMaxResults(1);
  return query.uniqueResult();
 }
 
 /**
  * Retorna objeto de acordo com a UniqueConstraint definida na Entidade
  * @param classe : Entidade a ser buscada
  * @param ids : Array contendo os IDS a serem buscados (na mesma ordem em que a UniqueConstraint foi definido)
  * @return Objeto encontrado no banco, caso n&#65533;o encontre ser&#65533; retornado NULL 
  * @throws Exception
  */
 @SuppressWarnings("unchecked")
 public static Object findByUniqueConstraints(Class classe, ArrayList<Object> ids) throws Exception {
  if (classe == null) {
   throw new Exception("classe n&#65533;o pode ser nula.");
  }
 
  if (ids == null || ids.size() == 0) {
   throw new Exception("ids n&#65533;o pode ser nulo.");
  }
 
  ArrayList<String> chaves = new ArrayList<String>();
  ArrayList<Class> tipos = new ArrayList<Class>();
  Annotation annotation = classe.getAnnotation(Table.class);
  if (annotation != null) {
   Table table = (Table) annotation;
 
   for (UniqueConstraint uniqueConstraint : table.uniqueConstraints()) {
    for (String column : uniqueConstraint.columnNames()) {
     tipos.add(classe.getDeclaredField(column).getType());
     chaves.add(column);
    }
   }
  } else {
   throw new Exception("Annotation @Table n&#65533;o encontrada na classe " + classe.getName());
  }
 
  if (chaves.size() == 0) {
   throw new Exception("UniqueConstraints n&#65533;o encontrada na annotation @Table da classe " + classe.getName());
  }
 
  if (chaves.size() != ids.size()) {
   throw new Exception("O n&#65533;mero de par&#65533;metros passados n&#65533;o confere com o n&#65533;mero de UniqueConstraints encontrados na classe " + classe.getName() + ". " + ids.size() + " foram passados, mas " + chaves.size() + " eram esparados.");
  }
 
  String str = "";
  for (int i = 0; i < chaves.size(); i++) {
   if (!ids.get(i).getClass().equals(tipos.get(i))) {
    throw new Exception("Tipos de dados incompat&#65533;veis. O par&#65533;metro n&#65533;mero " + i + " &#65533; incompat&#65533;vel, foi passado:" + ids.get(i).getClass().toString() + " e estava esperando: " + tipos.get(i).toString());
   }
   if (str.length() == 0) {
    str = " where a." + chaves.get(i) + " = " + ids.get(i);
   } else {
    str += " and " + chaves.get(i) + " = " + ids.get(i);
   }
  }
 
  Session em = HibernateUtil.getSessionFactory().openSession();
  Query query = em.createQuery("Select a from " + classe.getName() + " a " + str);
  query.setMaxResults(1);
  return query.uniqueResult();
 }
}

public void saveOrUpdate(List<Classe> lista) throws HibernateException {

    Session session = HibernateUtils.getSessionFactory().openSession();
    Transaction transaction = session.beginTransaction();

    try {
        for (Classe item : lista) {
            session.saveOrUpdate(item);
        }
        transaction.commit();
    }
    catch (HibernateException hibernateException) {
        if (transaction.isActive()) {
            transaction.rollback();
        }
    }
    finally {
        transaction.close();
        session.close();
    }
}

List<Classe> lista = new ArrayList<Classe>();
//popula sua coleção...

try {
    DAO.saveOrUpdate(lista);
}
catch (HibernateException hibernateException) {
     hibernateException.printStackTrace();
}