Inserção de dados não dúplicados

//Classe de Persistencia
public class DaoGeneric {

	static final Log log = LogFactory.getLog(DaoGeneric.class);

	public void inserirPalavra(Palavra palavra) {
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();
		
		try {
			log.info("Processando Palavra");
			session.saveOrUpdate(palavra);
			session.getTransaction().commit();

		} catch (Exception erro) {

			log.info("Erro na Inserção do Palavra : " + erro.getMessage()
					+ "\n\n" + palavra.getNomePalavra() + "\n\n");

			session.beginTransaction().rollback();
		}

	}

	public void inserirTipoPalavra(TipoPalavra nomeTipoPalavra) {

		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();

		try {
			log.info("Processando Tipo Palavra");
			session.saveOrUpdate(nomeTipoPalavra);
			session.getTransaction().commit();
		} catch (Exception erro) {
			session.update(nomeTipoPalavra);
			log.info("Erro na Inserção do Tipo de Palavra : " + erro
					+ nomeTipoPalavra.getNomeTipoPalavra());
		}
	}
}

//classe da tabela Palavra

@Entity
@Table(name = "palavra")
public class Palavra implements Serializable {

	private static final long serialVersionUID = 1L;
	private int idPalavra;
	private String nomePalavra;
	private Set<TipoPalavra> tipoPalavras = new HashSet<TipoPalavra>(0);

	public Palavra() {
	}

	public Palavra(int idPalavra, String nomePalavra) {
		this.idPalavra = idPalavra;
		this.nomePalavra = nomePalavra;
	}

	public Palavra(int idPalavra, String nomePalavra, Set<TipoPalavra> tipoPalavras) {
		this.idPalavra = idPalavra;
		this.nomePalavra = nomePalavra;
		this.tipoPalavras = tipoPalavras;
	}

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name = "id_palavra", nullable = false)
	public int getIdPalavra() {
		return this.idPalavra;
	}

	public void setIdPalavra(int idPalavra) {
		this.idPalavra = idPalavra;
	}

	@Column(name = "nome_palavra", nullable = false, length = 65, updatable=true, unique=true)
	public String getNomePalavra() {
		return this.nomePalavra;
	}

	public void setNomePalavra(String nomePalavra) {
		this.nomePalavra = nomePalavra;
	}

	@ManyToMany(fetch = FetchType.LAZY,cascade={CascadeType.ALL})
	@Cascade(value={org.hibernate.annotations.CascadeType.ALL})
	@JoinTable(name = "palavra_tipo_palavra", joinColumns = { @JoinColumn(name = "id_palavra", nullable = false, updatable = true) }, inverseJoinColumns = { @JoinColumn(name = "id_tipo_palavra", nullable = false, updatable = true) })
	public Set<TipoPalavra> getTipoPalavras() {
		return this.tipoPalavras;
	}

	public void setTipoPalavras(Set<TipoPalavra> tipoPalavras) {
		this.tipoPalavras = tipoPalavras;
	}

}


//Classe da tabela tipo palavra

@Entity
@Table(name = "tipo_palavra")
public class TipoPalavra implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	private int idTipoPalavra;
	private String nomeTipoPalavra;
	private Set<Palavra> palavras = new HashSet<Palavra>(0);

	public TipoPalavra() {
	}

	public TipoPalavra(int idTipoPalavra, String nomeTipoPalavra) {
		this.idTipoPalavra = idTipoPalavra;
		this.nomeTipoPalavra = nomeTipoPalavra;
	}

	public TipoPalavra(int idTipoPalavra, String nomeTipoPalavra, Set<Palavra> palavras) {
		this.idTipoPalavra = idTipoPalavra;
		this.nomeTipoPalavra = nomeTipoPalavra;
		this.palavras = palavras;
	}

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name = "id_tipo_palavra", nullable = false, unique = true, updatable=true)	
	public int getIdTipoPalavra() {
		return this.idTipoPalavra;
	}

	public void setIdTipoPalavra(int idTipoPalavra) {
		this.idTipoPalavra = idTipoPalavra;
	}

	@Column(name = "nome_tipo_palavra", nullable = false, length = 80)
	public String getNomeTipoPalavra() {
		return this.nomeTipoPalavra;
	}

	public void setNomeTipoPalavra(String nomeTipoPalavra) {
		this.nomeTipoPalavra = nomeTipoPalavra;
	}

	@ManyToMany(fetch = FetchType.LAZY, mappedBy = "tipoPalavras",cascade={CascadeType.ALL})
	@Cascade(value={org.hibernate.annotations.CascadeType.ALL})
	public Set<Palavra> getPalavras() {
		return this.palavras;
	}

	public void setPalavras(Set<Palavra> palavras) {
		this.palavras = palavras;
	}

}


//classe onde capturo o texto e faço a inserção

public class PalavraUtil {

	public static Hashtable<String, TipoPalavra> listpalavra = new Hashtable<String, TipoPalavra>();
	
	public void palavra() {
		Palavra palavra = new Palavra();
		DaoGeneric daopalavra = new DaoGeneric();
		try {
			FileInputStream fstream = new FileInputStream("file/write.txt");
			DataInputStream in = new DataInputStream(fstream);
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
			String strLine;	
			String tempo = null;
			while ((strLine = br.readLine()) != null) {
				
				if (strLine.contains(";")) {
					String[] temp = strLine.split(";");
					
					if(!listpalavra.containsKey(temp[0]))
					{
						TipoPalavra tipoPalavra2 = new TipoPalavra();
						tipoPalavra2.setNomeTipoPalavra(temp[0]);
						listpalavra.put(temp[0], tipoPalavra2);
						daopalavra.inserirTipoPalavra(tipoPalavra2);
					}				

					palavra = new Palavra();
					palavra.setNomePalavra(temp[1]);
					palavra.getTipoPalavras().add(listpalavra.get(temp[0]));

					daopalavra.inserirPalavra(palavra);

					continue;
				}
				
				if (strLine.equals("Presente do Indicativo")
						|| strLine.equals("Imperfeito do Indicativo")
						|| strLine.equals("Perfeito do Indicativo")
						|| strLine.equals("Mais-que-perfeito do Indicativo")
						|| strLine.equals("Futuro do Pretérito do Indicativo")
						|| strLine.equals("Futuro do Presente do Indicativo")
						|| strLine.equals("Presente do Subjuntivo")
						|| strLine.equals("Imperfeito do Subjuntivo")
						|| strLine.equals("Futuro do Subjuntivo")
						|| strLine.equals("Imperativo Afirmativo")
						|| strLine.equals("Imperativo Negativo")
						|| strLine.equals("Infinitivo Pessoal")
						|| strLine.equals("Substantivo")
						|| strLine.equals("Adverbio")
						|| strLine.equals("Adjetivo")) {
					tempo = strLine;
					if(!listpalavra.containsKey(strLine))
					{
						TipoPalavra TipoPalavra2 = new TipoPalavra();
						TipoPalavra2.setNomeTipoPalavra(strLine);						
						listpalavra.put(strLine, TipoPalavra2);
						daopalavra.inserirTipoPalavra(TipoPalavra2);
					}
					continue;
				}
				palavra = new Palavra();
				palavra.setNomePalavra(strLine);
				palavra.getTipoPalavras().add(listpalavra.get(tempo));
				daopalavra.inserirPalavra(palavra);
				//System.out.println("\n" + strLine.toLowerCase() + "\n");
			}			
			in.close();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
		}
	}
}


//classe main onde faço a bagaça rodar

public class App {
	
	static final Log log = LogFactory.getLog(App.class);
	
	public static void main(String[] args) {
		try {
			
			PalavraUtil palavraUtil = new PalavraUtil();
			palavraUtil.palavra();

		} catch (Exception e) {			
			log.info(e);
		}
	}
}

log.info("Processando Palavra");
			List cats = session.createCriteria(Palavra.class)
			.add( Restrictions.like("nomePalavra", ""+palavra.getNomePalavra()+"") )
			.list();
			
			if(cats.isEmpty()){
				log.info("Inserindo..... " + palavra.getNomePalavra());
				session.save(palavra);
			}else{
				log.info("Atualizando..... " + palavra.getNomePalavra());
				palavra = (Palavra) cats.get(0);				
				palavra.getTipoPalavras().add(tipoPalavra);
				session.merge(palavra);
			}