Duvida sobre duplicação de objeto?

Programação
#1

Olá amigos, comecei a criar um projeto do zero usando JSF + Primefaces + JPA + Hibernate e possuo um duvida.

1 - Possuo uma Entidade Fabricante, aonde essa entidade vai se relaciona com outra entidade só que já consigo persisitir o objeto normalmente, o meu problema é quando vou informar um nome de um Fabricante por exemplo Toyota, caso o nome já esteja no banco e caso tentar salvar o mesmo nome irei ficar com 2 objetos ex: Toyota / ToYoTa como faço para resolver isso?

OBS: Estou usando o lombook. Portanto, não está explicito as anotações @getters e @setter.

Segue meu código:

package com.irmaosuspension.controleservico.modelo;
import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.NotBlank;

import lombok.Data;

@Entity
@Data
public class Fabricante implements Serializable{

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long codigo;

    @NotNull
    @NotBlank
    @Size(max= 30,min = 4) //tamanho de caractere
    @Column(nullable = false, length=30) //coluna não pode ser null e o tamanho da coluna é 20
    private String nome;

    @Transient
    public boolean isFabricanteNovo(){
        return this.getCodigo() == null;
    }

    public boolean isExistente(){
        return !isFabricanteNovo();
    }}

Meu DAO

package com.irmaosuspension.controleservico.dao;

import java.io.Serializable;
import java.util.List;

import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;

import com.irmaosuspension.controleservico.jpa.Transactional;
import com.irmaosuspension.controleservico.modelo.Fabricante;
import com.irmaosuspension.controleservico.util.NegocioException;

public class FabricanteDAO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Inject
    private EntityManager em;


    @Transactional
    public void salvar(Fabricante fabricante) {
        em.merge(fabricante);
    }

    public List<Fabricante> buscarTodos() {
        return em.createQuery("from Fabricante order by nome", Fabricante.class).getResultList();
    }

    @Transactional
    public void excluir(Fabricante fabricante) throws NegocioException {
        try {
            Fabricante fabricanteTemp = this.buscarPeloCodigo(fabricante.getCodigo());
            em.remove(fabricanteTemp);
            em.flush();
        } catch (PersistenceException e) {
            throw new NegocioException("Fabricante não pode ser excluído.");
        }
    }

    public Fabricante buscarPeloCodigo(Long codigo) {
        return em.find(Fabricante.class, codigo);
    }

}
Meu Service

package com.irmaosuspension.controleservico.service;

import java.io.Serializable;
import java.util.List;

import javax.inject.Inject;

import com.irmaosuspension.controleservico.dao.FabricanteDAO;
import com.irmaosuspension.controleservico.modelo.Fabricante;
import com.irmaosuspension.controleservico.util.NegocioException;

public class FabricanteService implements Serializable {

    private static final long serialVersionUID = 1L;

    @Inject
    private FabricanteDAO fabricanteDAO;

    public void salvar(Fabricante fabricante) throws NegocioException {
        try{
        this.fabricanteDAO.salvar(fabricante);
        }
        catch (Exception e) {
            throw new NegocioException("Não foi possível salvar o Fabricante");
        }
    }

    public List<Fabricante> buscarTodos() {
        return fabricanteDAO.buscarTodos();
    }

    public void excluir(Fabricante fabricante) throws NegocioException {
        try {
            fabricanteDAO.excluir(fabricante);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            throw new NegocioException("Não foi possível excluir o Fabricante!");
        }
    }
}
Meu Controller

package com.irmaosuspension.controleservico.controller;

import java.io.Serializable;

import javax.faces.view.ViewScoped;
import javax.inject.Inject;
import javax.inject.Named;

import org.omnifaces.util.Messages;

import com.irmaosuspension.controleservico.modelo.Fabricante;
import com.irmaosuspension.controleservico.service.FabricanteService;
import com.irmaosuspension.controleservico.util.NegocioException;

import lombok.Getter;
import lombok.Setter;


@Named
@ViewScoped
public class CadastroFabricanteBean implements Serializable {


    private static final long serialVersionUID = 1L;

    @Inject
    private FabricanteService cadastroFabricanteService;

    @Getter
    @Setter
    private Fabricante fabricante;

    public void inicializar() {
        System.out.println("iniciando Fabricante..");
        if (this.fabricante == null) {
            limpar();
        }
    }

    public void salvar()throws NegocioException {
        try {
            this.cadastroFabricanteService.salvar(fabricante);
            Messages.addGlobalInfo("Fabricante salvo com sucesso!");
            limpar();
        } catch (NegocioException e) {
            Messages.addGlobalError(e.getMessage());
        }
    }

    public boolean isEditando() {
        return this.fabricante.getCodigo() != null;
    }

    private void limpar() {
        this.fabricante = new Fabricante();
    }
}
#2

Opa!

no seu controller no método salvar vc tem que verificar se o fabricante já existe.
uma sugestão seria criar um método private Boolean hasFabricante(Fabricante obj) e no DAO vc vai fazer um metodo que busca pela descrição se o resultado vir com linhas é porque existe então vc vai retornar true e vai tratar como se fosse um erro “Fabricante já cadastro”.

#3

Complementando o que o @brupinto falou, você também pode adicionar uma constraint no banco de dados para garantir que o nome do fabricante é único. Procure por unique constraints.

Agora, o problema com nomes, é que eles podem ser escritos de várias formas diferentes: minúsculo, maiúsculo, com espaço, com acentos, etc.
Se quiser garantir que o nome é realmente único, recomendo você manter uma versao “normalizada” do nome: em minúsculo, sem acentos, sem espacos, etc.
Daí quando for pesquisar se o nome já existe, você usa essa versao normalizada.

Claro, que você deve manter a versao original, para exibir para o usuário, mas usar a versao normalizada para fazer comparaçoes.