Utilizando Swing com Banco de Dados - MBallem

Programando com Java
Artigo – http://mballem.wordpress.com/
Utilizando Swing com Banco de Dados
Autor
Marcio Ballem: é formado em Sistemas de Informação e possui certificação Oracle Certified Professional, Java
SE 6 Programmer. Trabalhou profissionalmente com desenvolvimento em Delphi 7 e Java JEE.
Introdução
Muitos iniciantes em Java instalam, geralmente o Netbeans, e montam uma interface através dos
componentes visuais da IDE. Não é apenas o Netbeans que oferece esse recurso, o Eclipse, o Intellij Idea entre
outros também oferecem.
Com a interface montada eles querem fazer a ligação entre a interface e o banco de dados. Bom, é ai que
surge a dúvida. Como fazer?
Neste tutorial irei exemplificar de maneira bem simples, mas útil, de como resolver este problema. Iremos
utilizar conexão JDBC com banco de dados Mysql e a interface será feita no “braço”, como se costuma dizer
quando não utilizamos uma IDE para esse fim.
É claro que quem quiser utilizar uma IDE para construir sua interface, pode fazê-lo sem problemas, até por
que o intuito desse tutorial será como enviar e receber os dados do banco de dados por uma interface gráfica e
não como criar uma interface gráfica.
Também tentarei explicar e exemplificar como funciona o padrão Model View Controller ou MVC como
costuma ser chamado.
1. Arquivos necessários
Como a conexão será por JDBC, precisaremos do driver JDBC do Mysql, e também do Mysql instalado na
PC. Quem não quiser utilizar o Mysql, fique a vontade de utilizar qualquer outro gerenciador de banco de dados
ou mesmo um banco de dados do tipo standalone como Derby ou o HsqlDB (veja mais sobre eles em:
http://mballem.wordpress.com/2011/02/02/jdbc-com-banco-de-dados-standalone/).
Para baixar o Driver JDBC do Mysql, acesse: http://www.mysql.com/downloads/connector/j/. Após baixá-lo
adicione o arquivo mysql-connector-java-5.1.15-bin no projeto.
Para quem não tem o MySql instalado ainda, eu sugiro baixar o WampServer que vem com uma versão do
MySql e possui uma instalação bem mais rápida e simples, acesse http://www.wampserver.com/en/
Quem não quiser o WampServer, pode baixar o MySql em http://www.mysql.com/downloads/
2. Padrão MVC
O objetivo do Model View Controller (MVC) é separar os dados ou lógicas de negócios (Model) da interface
do usuário (View) e do fluxo da aplicação (Control). Utilizando este padrão seria possível reutilizar boa parte da
aplicação para a comunicação com outras interfaces e também torna mais fácil a manutenção na aplicação.
Imagine a situação em que você cria uma aplicação em Swing sem a utilização do padrão MVC. Na classe
que contém a interface você faz as chamadas a banco através de select, insert e demais métodos que se
comunicam com o banco de dados. Ok, sua aplicação vai funcionar perfeitamente como você queria.
Agora imagine que você precisa que essa aplicação seja também criada para a Web. Bom, você terá muito
trabalho, isto por que está tudo misturado na classe de interface. Na mesma classe você fez as chamadas a
banco de dados e as regras de negócio. Agora terá que refazer tudo isso para criar a aplicação no formato
Web.
Caso no primeiro projeto você tivesse usado o padrão MVC, não precisaria refazer tudo, apenas criaria uma
nova interface no padrão Web e a comunicaria com o seu controller. É claro que no controller teria que mudar
algumas coisas, por que o padrão Web trabalha com requisições e tudo mais, mas teria bem menos trabalho.
Esse trabalho seria bem menor também no caso de você simplesmente querer atualizar a sua interface em
Swing para um modelo diferente. Mudaria apenas a interface, os métodos principais da aplicação não
precisariam ser modificados.
Na aplicação que criaremos a seguir, o modelo MVC se aplica e pode ser visto mais ou menos assim:

Model: contém as classes Contato, ContatoDao, GenericDao e ConnectionDataBase

Controller: contém a classe ContatoController

View: contém a classe ContatoFrame
O processo funciona assim:
1.
O usuário clica em um botão na interface (View). Esse botão possui um evento que faz uma
chamada ao Controller
2.
O Controller atende essa chamada e então se comunica com o Model
3.
O Model executa, por exemplo, um acesso ao banco de dados, como uma consulta, e então retorna
uma resposta ao Controller que retorna uma resposta a View
É possível na View o acesso ao Model, como instanciar uma classe de entidade para ter acesso aos seus
métodos, mas nunca as classes que possuem relacionamentos com o banco de dados. No exemplo deste
tutorial foram passados para o Controller parâmetros tipo String, mas poderiam ser os objetos do tipo
Contato (Entidade Contato).
3. Tabela contatos
Vamos criar a tabela Contatos, para isso, rode o script da listagem 1. Observe que estamos utilizando auto
incremento para o id da tabela, assim quem se preocupa com a criação dos id’s é o gerenciador do banco de
dados.
Listagem 1. Contatos.sql
CREATE TABLE IF NOT EXISTS `contatos` (
`ID` BIGINT( 20 ) NOT NULL AUTO_INCREMENT ,
`NOME` VARCHAR( 50 ) NOT NULL UNIQUE ,
`APELIDO` VARCHAR( 15 ) NOT NULL ,
`DATA_NASCIMENTO` DATE NOT NULL ,
PRIMARY KEY ( `ID` )
)
4. Classe de conexão JDBC
Vamos criar a classe de conexão JDBC, conforme listagem 2.
Listagem 2. Classe ConnectionDataBase
package br.mb.tutorialJdbcsSwingMysql.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionDataBase {
private
private
private
private
static
static
static
static
final
final
final
final
String
String
String
String
URL_MYSQL = "jdbc:mysql://localhost/agenda";
DRIVER_CLASS = "com.mysql.jdbc.Driver";
USER = "root";
PASS = "";
public static Connection getConnection() {
System.out.println("Conectando ao Banco de Dados");
try {
Class.forName(DRIVER_CLASS);
return DriverManager.getConnection(URL_MYSQL, USER, PASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
throw new RuntimeException(e);
}
return null;
}
}
Para quem instalou o WampServer o usuário é “root” e a senha é vazia por padrão. Quem utilizou outra
instalação do Mysql, deve alterar para seu usuário e sua senha.
Criamos um método chamado getConnection() que retorna um objeto de conexão com o banco de dados.
Neste método chamamos o método estático getConnection(...) da classe DriverMenager, pelo qual passamos
as configurações para a conexão.
Quando precisarmos de uma conexão como o banco de dados, vamos apenas fazer uma chamada ao
método criado. Esta classe poderá ser utilizada com qualquer banco de dados, basta apenas alterar os
parâmetros DRIVER_CLASS, URL_MYSQL, USER, PASS e adicionar no projeto o driver JDBC referente ao
banco de dados usado.
5. Classe GenericDao
Vamos criar uma classe genérica para os métodos insert, update e delete, veja na listagem 3.
Listagem 3. Classe GenericDao
package br.mb.tutorialJdbcSwingMysql.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public abstract class GenericDao {
private Connection connection;
protected GenericDao() {
this.connection = ConnectionDataBase.getConnection();
}
protected Connection getConnection() {
return connection;
}
protected void save(String insertSql, Object... parametros) throws
SQLException {
PreparedStatement pstmt = getConnection().prepareStatement(insertSql);
for (int i = 0; i < parametros.length; i++) {
pstmt.setObject(i+1, parametros[i]);
}
pstmt.execute();
pstmt.close();
}
protected void update(String updateSql, Object id, Object... parametros)
throws SQLException {
PreparedStatement pstmt = getConnection().prepareStatement(updateSql);
for (int i = 0; i < parametros.length; i++) {
pstmt.setObject(i+1, parametros[i]);
}
pstmt.setObject(parametros.length + 1, id);
pstmt.execute();
pstmt.close();
}
protected void delete(String deleteSql, Object... parametros) throws
SQLException {
PreparedStatement pstmt = getConnection().prepareStatement(deleteSql);
for (int i = 0; i < parametros.length; i++) {
pstmt.setObject(i+1, parametros[i]);
}
pstmt.execute();
pstmt.close();
}
}
Esta classe poderá ser usada por qualquer outra classe que faça acesso ao banco de dados. A vantagem
de criar uma classe desse tipo é que não precisamos criar estes três métodos em cada classe que os
utilizarmos, precisamos apenas passar os parâmetros necessários para as ações com o banco de dados.
Veja que criamos um atributo connection, do tipo Connection, que recebe através do construtor da classe
uma conexão com o banco de dados sempre que a classe dao for instanciada. Essa conexão recebida vem
como retorno da classe ConnectionDataBase.
Os métodos são protected para que apenas as classes que herdam GenericDao possoam ter acesso a eles.
O método save() recebe dois parametros, o primeiro é o sql que contém o insert e o segundo é uma lista de
argumentos que pode passar vários parâmetros de uma só vez, algo muito parecido com um array, que
conterá o valor dos campos do insert. O método update() possui um parâmetro a mais, que será o id da coluna
que iremos executar o update.
6. Classe Contato
Nossa classe contato terá como atributos os campos da tabela Contatos. Para isso, crie a classe como na
listagem 4 e gere os métodos getters e setters. Veja que ela foi criada no pacote model, esse model não é o
mesmo Model do padrão MVC, é um pacote onde se costuma colocar as classes de entidades.
Listagem 4. Classe Contato
package br.mb.tutorialJdbcSwingMysql.model;
import java.sql.Date;
public class Contato {
private Long id;
private String nome;
private String apelido;
private Date dtNascimento;
//gere os métodos getters and setters
}
7. Classe ContatoDao
Criamos a classe GenericDao para ser herdadas pelos demais dao’s, assim, vamos agora criar a classe
ContatoDao, onde terão os métodos mais específicos da classe. Veja na listagem 5.
Listagem 5. Classe ContatoDao
package br.mb.tutorialJdbcSwingMysql.dao;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import
import
import
import
import
java.sql.PreparedStatement;
java.sql.ResultSet;
java.sql.SQLException;
java.util.ArrayList;
java.util.List;
public class ContatoDao extends GenericDao {
public void salvar(Contato contato) throws SQLException {
String insert = "INSERT INTO CONTATOS(nome, apelido, data_nascimento)
VALUES(?,?,?)";
save(insert, contato.getNome(), contato.getApelido(),
contato.getDtNascimento());
}
public void alterar(Contato contato) throws SQLException {
String update = "UPDATE CONTATOS " +
"SET nome = ?, apelido = ?, data_nascimento = ? " +
"WHERE id = ?";
update(update, contato.getId(), contato.getNome(), contato.getApelido(),
contato.getDtNascimento());
}
public void excluir(long id) throws SQLException {
String delete = "DELETE FROM CONTATOS WHERE id = ?";
delete(delete, id);
}
public List<Contato> findContatos() throws SQLException {
List<Contato> contatos = new ArrayList<Contato>();
String select = "SELECT * FROM CONTATOS";
PreparedStatement stmt = getConnection().prepareStatement(select);
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
Contato contato = new Contato();
contato.setId(rs.getLong("id"));
contato.setNome(rs.getString("nome"));
contato.setApelido(rs.getString("apelido"));
contato.setDtNascimento(rs.getDate("data_nascimento"));
contatos.add(contato);
}
rs.close();
stmt.close();
return contatos;
}
public Contato findByName(String nome) throws SQLException {
String select = "SELECT * FROM CONTATOS WHERE nome = ?";
Contato contato = null;
PreparedStatement stmt = getConnection().prepareStatement(select);
stmt.setString(1, nome);
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
contato = new Contato();
contato.setId(rs.getLong("id"));
contato.setNome(rs.getString("nome"));
contato.setApelido(rs.getString("apelido"));
contato.setDtNascimento(rs.getDate("data_nascimento"));
}
rs.close();
stmt.close();
return contato;
}
Veja que utilizamos herança nesta classe, herdando os métodos criados na classe GenericDao. Nossos
métodos salvar(), alterar() e excluir() possuem a criação do SQL que será executado no banco de dados e uma
chamada ao método da classe GenericDao, passando para ele o SQL e os demais parâmetros.
Os métodos salvar(), alterar() e excluir(), serão os métodos acessados pela classe ContatoController para
manipulação com o banco de dados. Ainda criamos mais dois métodos, um que retorna através de um select
uma lista com todos os contatos cadastrados no banco de dados e um que realizara um select pela coluna
nome da tabela contatos do banco de dados. Podem ser criadas mais consultas, mas para este tutorial vamos
utilizar apenas estes dois.
8. Classe ContatoController
A classe ContatoController será o relacionamento entre o banco de dados e a interface com o usuários,
assim, não iremos misturar na classe da interface métodos referentes ao banco de dados e a regras de
negócios. Crie a classe conforme a listagem 6.
Listagem 6. Classe ContatoController
package br.mb.tutorialJdbcSwingMysql.controller;
import br.mb.tutorialJdbcSwingMysql.dao.ContatoDao;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import
import
import
import
import
import
import
javax.swing.*;
java.sql.Date;
java.sql.SQLException;
java.text.DateFormat;
java.text.ParseException;
java.text.SimpleDateFormat;
java.util.List;
public class ContatoController {
private Date formatarData(String data) throws ParseException {
DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
return new Date( formatter.parse(data).getTime() );
}
public void salvar(String nome, String apelido, String dtNascimento) throws
SQLException, ParseException {
Contato contato = new Contato();
contato.setNome(nome);
contato.setApelido(apelido);
contato.setDtNascimento(formatarData(dtNascimento));
new ContatoDao().salvar(contato);
}
public void alterar(long id, String nome, String apelido, String dtNascimento)
throws ParseException, SQLException {
Contato contato = new Contato();
contato.setId(id);
contato.setNome(nome);
contato.setApelido(apelido);
contato.setDtNascimento(formatarData(dtNascimento));
new ContatoDao().alterar(contato);
}
public List<Contato> listaContatos() {
ContatoDao dao = new ContatoDao();
try {
return dao.findContatos();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "Problemas ao localizar contato\n"
+ e.getLocalizedMessage());
}
return null;
}
public void excluir(long id) throws SQLException {
new ContatoDao().excluir(id);
}
public Contato buscaContatoPorNome(String nome) throws SQLException {
ContatoDao dao = new ContatoDao();
return dao.findByName(nome);
}
}
A classe ContatoController faz a comunicação entre o banco de dados e a interface, utilizamos aqui o
modelo conhecido como MVC(Model View Controller), onde separamos regras de negócios e interface. Criamos
aqui um método para manipular a data. Os métodos desta classe serão chamados pela interface, e farão a
chamada aos métodos das classes dao’s para então retornar para a interface o resultado.
9. Classe ContatoFrame
Agora criaremos a nossa classe de interface com o usuário. Quem for criar a interface com auxilio de uma
IDE qualquer, tente apenas utilizar as mesmas nomenclaturas dos atributos e métodos para evitar problemas.
O resultado final será uma interface como a da figura 1.
Figura 1 - Interface Contatos 1
Listagem 7. Classe ContatoFrame
package br.mb.tutorialJdbcSwingMysql.frame;
import br.mb.tutorialJdbcSwingMysql.controller.ContatoController;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import
import
import
import
import
import
import
import
javax.swing.*;
java.awt.*;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
java.sql.SQLException;
java.text.ParseException;
java.text.SimpleDateFormat;
java.util.List;
public class ContatoFrame extends JFrame {
private
private
private
private
JLabel lbNome, lbApelido, lbDtNascimento;
JTextField txtNome, txtApelido, txtDtNascimento, txtLocalizar;
JButton btnSalvar, btnAlterar, btnExcluir, btnClear, btnLocalizar;
JButton btnPrimeiro, btnProximo, btnAnterior, btnUltimo;
private List<Contato> contatoList = new ContatoController().listaContatos();
private int registroAtual = 0;
public ContatoFrame() {
super("Contatos");
Container tela = getContentPane();
setLayout(null);
lbNome = new JLabel("Nome");
lbApelido = new JLabel("Apelido");
lbDtNascimento = new JLabel("Data de Nascimento(dd/mm/aaaa)");
lbNome.setBounds(10, 10, 240, 15);
lbApelido.setBounds(10, 50, 240, 15);
lbDtNascimento.setBounds(10, 90, 240, 15);
lbNome.setForeground(Color.BLACK);
lbApelido.setForeground(Color.BLACK);
lbDtNascimento.setForeground(Color.BLACK);
lbNome.setFont(new Font("Courier New", Font.BOLD, 14));
lbApelido.setFont(new Font("Courier New", Font.BOLD, 14));
lbDtNascimento.setFont(new Font("Courier New", Font.BOLD, 14));
tela.add(lbNome);
tela.add(lbApelido);
tela.add(lbDtNascimento);
txtNome = new JTextField();
txtApelido = new JTextField();
txtDtNascimento = new JTextField();
txtNome.setBounds(10, 25, 265, 20);
txtApelido.setBounds(10, 65, 265, 20);
txtDtNascimento.setBounds(10, 105, 265, 20);
tela.add(txtNome);
tela.add(txtApelido);
tela.add(txtDtNascimento);
btnSalvar = new JButton("Salvar");
btnAlterar = new JButton("Alterar");
btnExcluir = new JButton("Excluir");
btnClear = new JButton("Limpar");
btnPrimeiro = new JButton("|<");
btnAnterior = new JButton("<<");
btnProximo = new JButton(">>");
btnUltimo = new JButton(">|");
btnSalvar.setBounds(280, 25, 80, 20);
btnAlterar.setBounds(280, 65, 80, 20);
btnExcluir.setBounds(280, 105, 80, 20);
tela.add(btnSalvar);
tela.add(btnAlterar);
tela.add(btnExcluir);
btnPrimeiro.setBounds(10, 135, 50, 20);
btnAnterior.setBounds(60, 135, 50, 20);
btnClear.setBounds(110, 135, 75, 20);
btnProximo.setBounds(185, 135, 50, 20);
btnUltimo.setBounds(235, 135, 50, 20);
tela.add(btnPrimeiro);
tela.add(btnAnterior);
tela.add(btnClear);
tela.add(btnProximo);
tela.add(btnUltimo);
JLabel lbLocalizar = new JLabel("Localizar por nome");
lbLocalizar.setBounds(10, 160, 220, 20);
txtLocalizar = new JTextField();
txtLocalizar.setBounds(10, 180, 220, 20);
btnLocalizar = new JButton("Ir");
btnLocalizar.setBounds(230, 180, 55, 20);
tela.add(lbLocalizar);
tela.add(txtLocalizar);
tela.add(btnLocalizar);
setSize(400, 250);
setVisible(true);
setLocationRelativeTo(null);
btnSalvar.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickSalvar();
}
}
);
btnAlterar.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickAlterar();
}
}
);
btnExcluir.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickExcluir();
}
}
);
btnClear.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
clearFields();
registroAtual = 0;
}
}
);
btnLocalizar.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickLocalizar();
}
}
);
btnPrimeiro.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickPrimeiro();
}
}
);
btnAnterior.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickAnterior();
}
}
);
btnProximo.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickProximo();
}
}
);
btnUltimo.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
onClickUltimo();
}
}
);
}
private void onClickUltimo() {
registroAtual = contatoList.size() - 1;
getValores(registroAtual);
}
private void onClickProximo() {
if (registroAtual != contatoList.size() - 1) {
getValores(++registroAtual);
}
}
private void onClickAnterior() {
if (registroAtual != 0) {
getValores(--registroAtual);
}
}
private void onClickPrimeiro() {
registroAtual = 0;
getValores(registroAtual);
}
private void getValores(int index) {
if (index <= contatoList.size() - 1) {
Contato contatoAtual = contatoList.get(index);
txtNome.setText(contatoAtual.getNome());
txtApelido.setText(contatoAtual.getApelido());
txtDtNascimento.setText(new
SimpleDateFormat("dd/MM/yyyy").format(contatoAtual.getDtNascimento()));
}
}
private void onClickAlterar() {
ContatoController cc = new ContatoController();
long id = contatoList.get(registroAtual).getId();
try {
cc.alterar(id, txtNome.getText(), txtApelido.getText(),
txtDtNascimento.getText());
JOptionPane.showMessageDialog(this, "Contato alterado com sucesso!");
clearFields();
contatoList = new ContatoController().listaContatos();
} catch (SQLException e) {
JOptionPane.showMessageDialog(this, "Nao foi possivel alterar
contato!\n" + e.getLocalizedMessage());
} catch (ParseException e) {
JOptionPane.showMessageDialog(this, "Data possui formato inválido!\n"
+ e.getLocalizedMessage());
}
}
private void onClickSalvar() {
ContatoController cc = new ContatoController();
try {
cc.salvar(txtNome.getText(), txtApelido.getText(),
txtDtNascimento.getText());
JOptionPane.showMessageDialog(this, "Contato salvo com sucesso!");
clearFields();
contatoList = new ContatoController().listaContatos();
} catch (SQLException e) {
JOptionPane.showMessageDialog(this, "Nao foi possivel salvar
contato!\n" + e.getLocalizedMessage());
} catch (ParseException e) {
JOptionPane.showMessageDialog(this, "Data possui formato inválido!\n"
+ e.getLocalizedMessage());
}
}
private void onClickExcluir() {
ContatoController cc = new ContatoController();
long id = contatoList.get(registroAtual).getId();
try {
cc.excluir(id);
JOptionPane.showMessageDialog(this, "Contato excluido com sucesso!");
clearFields();
contatoList = new ContatoController().listaContatos();
} catch (SQLException e) {
JOptionPane.showMessageDialog(this, "Nao foi possivel excluir o
contato!\n" + e.getLocalizedMessage());
}
}
private void onClickLocalizar() {
ContatoController cc = new ContatoController();
try {
Contato c = cc.buscaContatoPorNome(txtLocalizar.getText());
txtNome.setText(c.getNome());
txtApelido.setText(c.getApelido());
txtDtNascimento.setText(new
SimpleDateFormat("dd/MM/yyyy").format(c.getDtNascimento()));
} catch (SQLException e) {
JOptionPane.showMessageDialog(this, "Ocorreu um erro, tente
novamente!\n" + e.getLocalizedMessage());
} catch (NullPointerException e){
JOptionPane.showMessageDialog(this, "Contato não localizdo ou não
existe!\n" + e.getLocalizedMessage());
}
}
private void clearFields() {
txtNome.setText("");
txtApelido.setText("");
txtDtNascimento.setText("");
txtLocalizar.setText("");
}
public static void main(String[] args) {
ContatoFrame frame = new ContatoFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Nesta classe temos a criação da interface com usuário e os métodos que se comunicam com o controller
para enviar ou receber dos dados do banco de dados. Além dos atributos referentes aos componentes da
interface, foram criados mais dois atributos, o contatoList e o registroAtual. O contatoList é uma lista que irá
guarda a consulta do banco de dados para a visualização de todos os contatos cadastrados. O registroAtual irá
guaradar a posição atual do regitro na lista, que será útil para a navegação entre os registros.
Os métodos onClickUltimo(), onClickProximo(), onClickAnterior() e onClickPrimeiro() enviarão para o método
getValores() a posição atual na lista, para então os campos do formulário serem preenchidos com estes
valores. Esta navegação é feita toda dentro da lista, assim poupa o trabalho de ficar abrindo e fechando a
conexão com o banco de dados a todo momento, o que é considerado um alto custo para uma apliação.
Os métodos onClickSalvar(), onClickExcluir() e onClickAlterar(), passam por parâmetros os dados
necessários para os métodos no controller interagirem com o banco de dados.
O método onClickLocalizar() irá fazer uma consulta através do parâmetro nome. O parâmetro deve ser
digitado no campo especifico e o clique no botão “Ir“ faz a chamada ao método onClickLocalizar() que se
comunica com o controller. O controller faz a chamada aos dao’s que retorna o resultado da consuta.
O método clearFields() serve apenas para limpar os campos quando estiverem preenchidos com dados.
Sobre a utilização do padrão MVC, por exemplo, no método onClickSalvar() poderia ao invés de enviar 3
parâmetros do tipo String, um unico parâmetro do tipo Contato. Assim, ao invés de criar o objeto contato no
controller como foi feito, criariamos dentro do método onClickSalvar().
Conclusão
Este tutorial exemplificou de forma simples como utilizar SWING com Banco de Dados. Também
exemplificou como utilizar o padrão MVC.
Agora que você já sabe como criar os eventos com o banco de dados através da interface, experimente
criar outras tabelas no banco de dados e outras interfaces para testar o que aprendeu até aqui. Lembre-se,
para cada tabela criada, crie uma nova entidade, um novo dao especifico e um novo controller.
Saiba mais

Model View Controller http://pt.wikipedia.org/wiki/MVC.

MySql http://www.mysql.com/

JDBC artigo Guj http://www.guj.com.br/articles/7

JDBC tutorial Oracle http://download.oracle.com/javase/tutorial/jdbc/index.html

Netbeans http://netbeans.org

Eclipse http://www.eclipse.org/downloads/

Intellij Idea http://www.jetbrains.com/idea/download/