Utilizando Swing com Banco de Dados
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: 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,GenericDaoeConnectionDataBase - Controller: contém a classe
ContatoController - View: contém a classe
ContatoFrame
O processo funciona assim:
- O usuário clica em um botão na interface (View). Esse botão possui um evento que faz uma chamada ao Controller
- O Controller atende essa chamada e então se comunica com o Model
- 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.
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.
package br.mb.tutorialJdbcsSwingMysql.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionDataBase {
private static final String URL_MYSQL = "jdbc:mysql://localhost/agenda";
private static final String DRIVER_CLASS = "com.mysql.jdbc.Driver";
private static final String USER = "root";
private static final String 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.
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();
connection.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();
connection.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();
connection.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 possam 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 parametro 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.
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.
package br.mb.tutorialJdbcSwingMysql.dao;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import 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 findContatos() throws SQLException {
List contatos = new ArrayList();
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();
getConnection().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();
getConnection().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.
package br.mb.tutorialJdbcSwingMysql.controller;
import br.mb.tutorialJdbcSwingMysql.dao.ContatoDao;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import javax.swing.*;
import java.sql.Date;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import 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 listaContatos() {
ContatoDao dao = new ContatoDao();
try {
return dao.findContatos();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null,
"Problemas ao localizar contaton" +
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
package br.mb.tutorialJdbcSwingMysql.frame;
import br.mb.tutorialJdbcSwingMysql.controller.ContatoController;
import br.mb.tutorialJdbcSwingMysql.model.Contato;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.List;
public class ContatoFrame extends JFrame {
private JLabel lbNome, lbApelido, lbDtNascimento;
private JTextField txtNome, txtApelido, txtDtNascimento, txtLocalizar;
private JButton btnSalvar, btnAlterar, btnExcluir, btnClear, btnLocalizar;
private JButton btnPrimeiro, btnProximo, btnAnterior, btnUltimo;
private List contatoList = new ContatoController().listaContatos();
private int registroAtual = 0;
private Long key;
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 = 0L;
if (key == null) {
id = contatoList.get(registroAtual).getId();
} else {
id = key;
key = null;
}
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())
);
key = c.getId();
} 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 registro 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 aplicação.
Os métodos onClickSalvar(), onClickExcluir() e onClickAlterar(), passam por parametros 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 parametro nome. O parametro 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 parametros do tipo String, um unico parametro 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
