Erro de atualização em JTable após manipulação no Banco de Dados - (Efeito duplic.) [RESOLVIDO]

/**
     * Método que atualiza o Modelo a partir da tabela na Visão.
     */
    public void updateModelFromTable() {
        //Se foi selecionada alguma linha:
        if(view.getLinhaSelecionadaTabela() != -1) {
            this.tableModel = view.getBairrosTableModel();
            //Aqui óh, recebendo mesma referência:
            this.vo = tableModel.getBairro(view.getLinhaSelecionadaTabela());
            //Renderiza a View:
            view.ativarNomeTextField(true);
            view.ativarDescricaoTextArea(true);
            view.ativarBtnLimpar(true);
            view.ativatBtnExcluir(true);
            view.ativarBtnCancelar(true);
            view.ativarBtnSalvar(false);
            view.ativarBtnAtualizar(true);
        } 
        //Se não foi selecionada nenhuma linha objeto 'vo' é nulo:
        else {
            this.vo = null;
        }
    }

package br.view;

import br.model.vo.BairroVO;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.table.AbstractTableModel;

/**
 *
 * @author Leandro
 */
public class BairrosTableModel extends AbstractTableModel {
    private List<BairroVO> linhas;
    private String colunas[] = new String[] {"Código", "Nome", "Descrição"};
    
    public BairrosTableModel() {
        this.linhas = new ArrayList<>();
    }
    
    public BairrosTableModel(List<BairroVO> lista) {
        this.linhas = new ArrayList<>(lista);
    }

    @Override
    public int getRowCount() {
        return linhas.size();
    }

    @Override
    public int getColumnCount() {
        return colunas.length;
    }
    
    @Override
    public String getColumnName(int columnIndex) {
        return colunas[columnIndex];
    }
    
    @Override
    public Class<?> getColumnClass(int columnIndex) {
        switch(columnIndex) {
            case 0: //ID
                return Integer.class;
            case 1: //Nome
                return String.class;
            case 2: //Descrição
                return String.class;
            default:
                throw new IndexOutOfBoundsException("Índice informado fora dos limites.");
        }
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        BairroVO vo = linhas.get(rowIndex);
        switch(columnIndex) {
            case 0: //ID
                return vo.getID();
            case 1: //Nome
                return vo.getNome();
            case 2: //Descrição
                return vo.getDescricao();
            default:
                throw new IndexOutOfBoundsException("Índice informado fora dos limites.");
        }
    }
    
    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
//        BairroVO vo = linhas.get(rowIndex);
//        switch(columnIndex) {
//            case 0: //ID
//                vo.setID(Integer.parseInt(aValue.toString()));
//            case 1: //Nome
//                vo.setNome(aValue.toString());
//            case 2: //Descrição
//                vo.setDescricao(aValue.toString());
//        }
//        fireTableCellUpdated(rowIndex, columnIndex);
    }
    
    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return false;
    }
    
    /*
     * Implementações particulares:
     */
    
    public BairroVO getBairro(int rowIndex) {
        return linhas.get(rowIndex);
    }
    
    public void addBairro(BairroVO vo) {
        linhas.add(vo);
        int lastIndex = getRowCount()-1;
        fireTableRowsInserted(lastIndex, lastIndex);
    }
    
    public void updateBairro(BairroVO vo, int index) {
        linhas.set(index, vo);
        fireTableRowsUpdated(linhas.indexOf(vo), linhas.indexOf(vo));
    }
    
    public void removeBairro(int rowIndex) {
        linhas.remove(rowIndex);
        fireTableRowsDeleted(rowIndex, rowIndex);
    }
    
    public void removeBairro(BairroVO vo) {
        linhas.remove(vo);
        fireTableRowsDeleted(linhas.indexOf(vo), linhas.indexOf(vo));
    }
    
    public void removeBairro(List<BairroVO> lista) {
        int indice = 0;
        for(BairroVO v : lista) {
            indice = linhas.indexOf(v);
            linhas.remove(v);
            fireTableRowsDeleted(indice, indice);
        }
    }
    
    public void addListaBairros(List<BairroVO> lista) {
        int tamanhoAntigo = getRowCount();
        linhas.addAll(lista);
        fireTableRowsInserted(tamanhoAntigo, getRowCount()-1);
    }
    
    public void limpar() {
        if(!linhas.isEmpty()) {
            linhas.clear();
            fireTableDataChanged();
        }
    }
    
    public boolean isEmpty() {
        return linhas.isEmpty();
    }
    
    public void ordenarPorID() {
        Collections.sort(linhas, new Comparator<BairroVO>(){
          
            @Override
            public int compare(BairroVO o1, BairroVO o2) {
                return o1.getID()-o2.getID();
            }
        });
        fireTableDataChanged();
    }
    
    public void ordenarPorNome() {
        Collections.sort(linhas, new Comparator<BairroVO>() {

            @Override
            public int compare(BairroVO o1, BairroVO o2) {
                return o1.getNome().compareTo(o2.getNome());
            }
        });
        fireTableDataChanged();
    }
    
    public void ordenarPorDescricao() {
        Collections.sort(linhas, new Comparator<BairroVO>() {
           
            @Override
            public int compare(BairroVO o1, BairroVO o2) {
                return o1.getDescricao().compareTo(o2.getDescricao());
            }
        });
        fireTableDataChanged();
    }
}

package br.presenter;

import br.model.dao.BairroDAO;
import br.model.vo.BairroVO;
import br.presenter.listeners.CadastroBairrosMouseListeners;
import br.presenter.listeners.CadastroBairrosWindowListeners;
import br.view.BairrosTableModel;
import br.view.CadastroBairrosView;
import java.awt.Component;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;

/**
 *
 * @author Leandro
 */
public class CadastroBairrosPresenter {
    private BairroVO vo;
    private BairroDAO dao;
    private CadastroBairrosView view;
    private BairrosTableModel tableModel;
    
    public CadastroBairrosPresenter(BairroDAO dao, CadastroBairrosView view) {
        this.vo = new BairroVO();
        this.dao = dao; //Recebe por uma factory de DAOS.
        this.view = view;
        //Popula o modelo de tabela na sua inicialização:
        this.tableModel = new BairrosTableModel(this.dao.listarTodos());
        
        /*
         * Seta o TableModel da JTable, sem isso teremos uma 'java.lang.ClassCastException', 
         * ao tentar recuperar o modelo de tabela da Visão, pois o modelo pradrão do JTable 
         * que é 'DefaultTableModel' não implementa a interface 'TableModel', porém o modelo 
         * 'BairrosTableModel' (extends AbstractTableModel) implementa 'TableModel', 
         * permitindo assim o casting no momento em que formos recuperar o modelo da Visão.
        */
        view.setBairrosTableModel(tableModel);
    }
    
    /**
     * Método para criação da janela de cadastro.
     * Este método adiciona os ouvintes, habilita a ediçao e exibe a janela.
     */
    public void criarJanela() {
        this.setUpViewListeners();
        this.ativarEdicao(true);
        this.view.ativarBtnAtualizar(false);
        this.view.ativatBtnExcluir(false);
        this.view.packAndShow();
    }
    
    /**
     * Chame este método para ocultar a janela.
     * @see Método 'exibirDialogoFechar()'.
     */
    public void ocultarJanela() {
        exibirDialogoFechar();
    }
    
    /**
     * Chame este método para retornar a Visão utilizada atualmente.
     */
    public CadastroBairrosView getView() {
        return this.view;
    }
    
    /**
     * Verifica se o objeto 'vo' recebeu uma referência da lista do TableModel, 
     * e caso tenha recebido, o objeto 'vo' recebe uma nova instância para que
     * seja incluida na lista a fim de evitar que existam dois ou mais objetos com
     * a mesma referência na lista e assim causar o "efeito do atributo mutável".
     * Se: VO igual a nulo = Desistiu de atualização;
     * Se: VO.getID diferente de 0 = Selecionou registro para atualizar.
     */
    public void verifyModelToInsert() {
        if(this.vo == null || this.vo.getID() != 0) {
            this.vo = new BairroVO();
        }
    }
    
    /**
     * Método que atualiza o Modelo a partir da Visão.
     */
    public void updateModelFromView() {
        this.vo.setNome(view.getNome());
        this.vo.setDescricao(view.getDescricao());
    }
    
    /**
     * Método que atualiza o Modelo a partir da tabela na Visão.
     */
    public void updateModelFromTable() {
        //Se foi selecionada alguma linha:
        if(view.getLinhaSelecionadaTabela() != -1) {
            this.tableModel = view.getBairrosTableModel();
            this.vo = tableModel.getBairro(view.getLinhaSelecionadaTabela());
            //Renderiza a View:
            view.ativarNomeTextField(true);
            view.ativarDescricaoTextArea(true);
            view.ativarBtnLimpar(true);
            view.ativatBtnExcluir(true);
            view.ativarBtnCancelar(true);
            view.ativarBtnSalvar(false);
            view.ativarBtnAtualizar(true);
        } 
        //Se não foi selecionada nenhuma linha objeto 'vo' é nulo:
        else {
            this.vo = null;
        }
    }
    
    /**
     * Método que atualiza a Visão a partir do Modelo.
     */
    public void updateViewFromModel() {
        if(vo != null) {
            this.view.setNome(vo.getNome());
            this.view.setDescricao(vo.getDescricao());
        } 
        else {
            verifyModelToInsert();
            restaurarEdicaoInicial();
        }
    }
    
    /**
     * Método que retorna uma lista com os itens a excluir conforme a seleção
     * do usuário na tabela.
     */
    public List<BairroVO> getListaExcluir() {
        int selecionados [] = view.getLinhasSelecionadasTabela();
        List<BairroVO> excluidos = new ArrayList<>();
        if(selecionados.length > 0) {
            for(int i = 0; i < selecionados.length; i++) {
                excluidos.add(tableModel.getBairro(selecionados[i]));
            }
        }
        return excluidos;
    }
    
    /**
     * Método para repopular o TableModel a partir de uma listagem dos registros
     * no Banco de Dados.
     */
    public void repopularTabela() {
        List<BairroVO> lista = dao.listarTodos();
        view.getBairrosTableModel().limpar();
        view.setBairrosTableModel(new BairrosTableModel(lista));
        view.atualizarTabelaBairros();
    }
    
    /**
     * Este método ativa todos os campos e botões disponíveis na Visão.
     * @param b A opção de ativar ou desativar os campos e botões na Visão.
     */
    public void ativarEdicao(boolean b) {
        view.ativarNomeTextField(b);
        view.ativarDescricaoTextArea(b);
        view.ativarBtnSalvar(b);
        view.ativarBtnAtualizar(b);
        view.ativarBtnLimpar(b);
        view.ativatBtnExcluir(b);
        view.ativarBtnCancelar(b);
    }
    
    /**
     * Método para restaurar a edição inicial na janela, limpando os campos, 
     * desativando os botões de Excluir e Atualizar.
     * Este método também "limpa" o objeto 'vo' por ser um atributo mutável, 
     * para evitar erros de atualização nas listas de registros da tabela.
     */
    public void restaurarEdicaoInicial() {
        this.view.limparCampos();
        this.view.limparSelecaoTabela();
        this.view.ativatBtnExcluir(false);
        this.view.ativarBtnAtualizar(false);
        this.view.ativarBtnSalvar(true);
    }
    
    /**
     * Método para atualizar o TableModel conforme a operação executada.
     * @param operacao A operação realizada.
     * Informe: 0 para inserção.
     * Informe: 1 para deleção.
     * Informe: 2 para atualização.
     */
    public void updateTableModel(int operacao) {
        //Inserir:
        if(operacao == 0) {
            vo.setID(dao.listarUltimoID());
            view.getBairrosTableModel().addBairro((BairroVO)vo.clone());
        }
        //Deletar:
        else if(operacao == 1) {
            view.getBairrosTableModel().removeBairro(getListaExcluir());
        }
        //Atualizar:
        else if(operacao == 2) {
            view.getBairrosTableModel().updateBairro(vo, view.getLinhaSelecionadaTabela());
        }
    }
    
    /**
     * Este método permite inserir um novo registro no Modelo da Tabela e no 
     * Banco de Dados chamando os métodos de outros objetos para realizar a 
     * persistência dos dados inseridos na Visão.
     */
    public void inserirBairro() {
        verifyModelToInsert();
        this.updateModelFromView();
        this.dao.inserir(vo);
        //Chama 'updateTableModel()' para atualizar o TableModel:
        this.updateTableModel(0);
        //Renderiza a tabela:
        view.atualizarTabelaBairros();
    }
    
    /**
     * Este método permite atualizar um registro no Modelo de Tabela e no Banco de Dados
     * com os dados que foram alterados na Visão chamando os métodos de outros objetos 
     * para realizar a persistência.
     */
    public void atualizarBairro() {
        this.updateModelFromView();
        this.dao.atualizar(vo);
        //Chama 'updateTableModel()' para atualizar o TableModel:
        updateTableModel(2);
        //Renderiza a tabela:
        view.atualizarTabelaBairros();
        //Restaura a edição inicial para inserir ou atualizar um registro:
        restaurarEdicaoInicial();
    }
    
    /**
     * Este método permite deletar um registro no Modelo de Tabela e no Banco de Dados
     * através da seleção de um ou mais registros na JTable pelo usuário.
     * @see Método 'exibirDialogoFechar()'.
     */
    public void deletarBairro() {
        //Se não selecionou nenhum registro:
        if(view.getLinhaSelecionadaTabela() == -1) {
            JOptionPane.showMessageDialog((Component)getView(), "Selecione um ou mais registros para excluir!",
                    "Excluir registros", JOptionPane.WARNING_MESSAGE);
        }
        //Se selecionou algum registro:
        else {
            //Atualiza o modelo com os dados vindos da seleção na tabela:
            this.updateModelFromTable();
            //Chama a exibição de um diálogo de confirmação:
            exibirDialogoDeletar();
        }
    }
    
    /**
     * Método para ocultar a janela de cadastro.
     * Pergunta ao usuário se realmente deseja sair,
     * caso contrário a execução da janela de cadastro continua.
     */
    private void exibirDialogoFechar () {
        // TODO add your handling code here:
        //Modifica o texto dos botões.
        Object [] options = {"Sim",
                             "Não"};
        //Variável 'n' recebe o valor da opção clicada.
        int n = JOptionPane.showOptionDialog ((Component)getView(),
                "Deseja realmente sair da aplicação?",
                "Encerrar aplicação",
                JOptionPane.YES_NO_CANCEL_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null,
                options,
                options [1]);
        //Se Clicou para sair.
        if (n==0) {
            /*
             * Torna a janela invisível em seguida
             * termina a execução do objeto.
             */
            view.ocultar();
            view.destruir();
        }
    }
    
    /**
     * Este método exibe uma caixa de confirmação para a exclusão de registros.
     */
    private void exibirDialogoDeletar() {
        // TODO add your handling code here:
        //Modifica o texto dos botões.
        Object [] options = {"Sim",
                             "Não"};
        //Variável ´n´ recebe o valor da opção clicada.
        int n = JOptionPane.showOptionDialog ((Component)getView(),
                "Deseja realmente excluir o(s) registro(s)?",
                "Exclusão de registros",
                JOptionPane.YES_NO_CANCEL_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null,
                options,
                options [1]);
        if (n==0) {
            //Manda uma lista com itens para o DAO realizar a exclusão do Banco de Dados:
            this.dao.deletar(getListaExcluir());
            //Chama 'updateTableModel()' para atualizar o TableModel:
            this.updateTableModel(1);
            //Renderiza a tabela:
            view.atualizarTabelaBairros();
            //Restaura a edição inicial para inserir, deletar ou atualizar um registro:
            restaurarEdicaoInicial();
        }
    }
    
    /**
     * Chame este método no momento de construir a janela, este método adiciona
     * os ouvintes nos componentes.
     */
    public void setUpViewListeners() {
        view.setSalvarActionListener(new CadastroBairrosWindowListeners.SalvarActionListener(this));
        view.setAtualizarActionListener(new CadastroBairrosWindowListeners.AtualizarActionListener(this));
        view.setLimparActionListener(new CadastroBairrosWindowListeners.LimparActionListener(this));
        view.setExcluirActionListener(new CadastroBairrosWindowListeners.ExcluirActionListener(this));
        view.setCancelarActionListener(new CadastroBairrosWindowListeners.CancelarActionListener(this));
        view.setFormularioWindowAdpter(new CadastroBairrosWindowListeners.FormularioWindowAdapter(this));
        view.setFieldNomeFocusListener(new CadastroBairrosWindowListeners.FieldNomeFocusListener(this));
        view.setFieldDescricaoFocusListener(new CadastroBairrosWindowListeners.FieldDescricaoFocusListener(this));
        view.setTableBairrosMouseListener(new CadastroBairrosMouseListeners.TabelaBairrosMouseListener(this));
    }
}