O passo a passo para a criação de uma aplicação usando Java, com Banco de Dados

(BD) chamado H2 na estrutura MVC (Modelo, Visão e Controle).

Será um exemplo com uma única classe sendo armazenada no BD.

Para os códigos que seguem abaixo, em todas as classes deve-se incluir o package
correto e adicionar os imports necessários. Observe a divisão abaixo:
texto planocopiar para memóriaimprimir?

1. - gui (Visão)  
2.   - LoginGUI  
3.   - ApiculturaGUI  
4.   - ClienteGUI  
5. - controller (Controle)  
6.   - ApiculturaController   
7.   - IncluirClienteController  
8. - persistência (Modelo)  
9.   - ClienteDAO  
10.   - FactoryConnection  
11. - dominio (Modelo)  
12.   - Cliente   

A primeira classe contém o famoso psvm (public static void main), que inicia a
execução da aplicação:
texto planocopiar para memóriaimprimir?

1. public class Apicultura {  
2.    public static void main(String[] args) {  
3.       ApiculturaController app = new ApiculturaController();  
4.    }  
5. }  

A classe ApiculturaController.java controla a janela de Login e a que contém o Menu.

Se o usuário acertar a senha, que é única, a janela com menu será apresentada, caso
contrário a aplicação é finalizada.
São instanciadas as classes com a interface gráfica e aqui são tratados os eventos.
texto planocopiar para memóriaimprimir?

1. public class ApiculturaController {  
2.    private ApiculturaGUI gui = null;  
3.    private LoginGUI guiLog = null;  
4.       
5.    public ApiculturaController() {  
6.       guiLog = new LoginGUI();  
7.       guiLog.adicionarOuvinteLogin (new OuvinteLogin());  
8.    }  
9.       
10.    class OuvinteLogin implements ActionListener {  
11.       public void actionPerformed (ActionEvent ev){  
12.          if (ev.getActionCommand() == "OK") {  
13.             String senha = String.valueOf(guiLog.pfSenha.getPassword());  
14.             if (senha.compareTo("SENHA")==0) {  
15.                 guiLog.dispose();         // fecha a janela de login  
16.                 gui = new ApiculturaGUI();  
17.                 gui.adicionarOuvinte(new OuvinteIncluir());  
18.             }  
19.             else {  
20.                 JOptionPane.showMessageDialog(null, "Senha Inválida!");  
21.                 System.exit(0);  
22.             }  
23.          }  
24.          else   System.exit(0);  
25.       }  
26.    }  
27.   
28.    class OuvinteIncluir implements ActionListener {  
29.       public void actionPerformed (ActionEvent ev) {  
30.          Object fonte = ev.getSource();  
31.          if (ev.getSource() instanceof JMenuItem) {  
32.              if (fonte == gui.mcSair) {  
33.                  System.exit (0);  
34.              }   
35.              else   
36.                  if (fonte == gui.mcCadastro) {  
37.                      IncluirClienteController clienteController =   
38.                                    new IncluirClienteController();  
39.                      gui.desktop.add(clienteController.guiCli);  
40.                  }    
41.           }  
42.        }  
43.    }  
44. }  
A classe LoginGUI.java deve conter os componentes em seu método construtor e a
adição dos eventos, que são tratados na classe de controle (ApiculturaController.java).
texto planocopiar para memóriaimprimir?

1. public class LoginGUI extends JFrame {  
2.    // declarar os componentes aqui como public  
3.   
4.    public LoginGUI() {  
5.         // tratar a parte gráfica aqui  
6.    }  
7.        
8.    public void adicionarOuvinteLogin (ActionListener ouvinte) {  
9.       this.btOK.addActionListener(ouvinte);  
10.       this.btCancelar.addActionListener(ouvinte);  
11.    }  
12. }  

Um exemplo para a interface gráfica de Login é a seguinte:

A classe ApiculturaGUI.java é a que contém o menu, usando as classes DesktopPane e

JInternalFrame. Observe a implementação:
texto planocopiar para memóriaimprimir?

1. public class ApiculturaGUI extends JFrame {  
2.    public JDesktopPane desktop;  
3.    public JMenuBar barraDeMenu;  
4.    public JMenuItem mcCadastro, mpCadastro, mcSair, miSobre;  
5.    
6.    public ApiculturaGUI() {  
7.       this.setTitle("Sistema de Controle de Produção Apícula");  
8.       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
9.   
10.       barraDeMenu = criaMenu();  
11.       this.setJMenuBar(barraDeMenu);  
12.   
13.       desktop = new JDesktopPane();  
14.       this.setContentPane(desktop);  
15.       this.setVisible(true);  
16.    }  
17.    
18.    public JMenuBar criaMenu() {  
 19.       // crie seu menu com os componentes JMenu, JMenuBar e JMenuItem   
20.    }  
21.    
22.    public void adicionarOuvinte (ActionListener ouvinte) {  
23.       this.mcCadastro.addActionListener(ouvinte);  
24.       this.mcSair.addActionListener(ouvinte);  
25.    }  
26. }  

Como aconteceu na classe LoginGUI.java, a classe ApiculturaGUI deve conter os

componentes para a criação do menu em seu método construtor e a adição dos eventos,
que são tratados na classe de controle (ApiculturaController.java).

Veja como fica o Front-end da aplicação:

Observe que o JPanel contém uma imagem de fundo. Para maiores detalhes, acesse a
explicação clicando aqui.

A próxima classe é a IncluirClienteController.java que chama a interface gráfica para a

classe Cliente e trata os eventos que serão adicionados pela classe ClienteGUI.java.
texto planocopiar para memóriaimprimir?

1. public class IncluirClienteController {  
2.    public ClienteGUI guiCli;  
3.    
4.    public IncluirClienteController() {  
5.       guiCli = new ClienteGUI();  
6.           
7.       guiCli.adicionarOuvinteCliente1 (new OuvinteIncluirCliente1());  
8.    }  
9.    
10.    class OuvinteIncluirCliente1 implements ActionListener {  
11.       public void actionPerformed(ActionEvent ev){  
12.          Object fonte = ev.getSource();  
13.          if (fonte == guiCli.bSaiCli)  
14.              guiCli.dispose();  
15.          else if (fonte == guiCli.bLimCli)  
16.                   guiCli.limparCampos();  
17.          else if (fonte == guiCli.bExcCli) {  
18.                   ClienteDAO clienteDAO = new ClienteDAO();  
19.                   clienteDAO.excluirCliente(guiCli.tfcodcli.getText());  
20.                   guiCli.limparCampos();  
21.               }  
22.          else if (fonte == guiCli.bConCli) {      
23.                   ClienteDAO clienteDAO = new ClienteDAO();  
24.                   Cliente cliente = clienteDAO.consultarCliente();  
25.                   if (cliente != null)  
26.                       mostrarCliente(cliente);  
27.               }  
28.          else if (fonte == guiCli.bIncCli) {  
29.                   ClienteDAO clienteDAO = new ClienteDAO();  
30.                   Cliente cliente = obterCliente();  
31.                   clienteDAO.incluirCliente(cliente);   
32.                   guiCli.limparCampos();  
33.               }      
34.          else if (fonte == guiCli.bAltCli)  
35.                   ClienteDAO clienteDAO = new ClienteDAO();  
36.                   Cliente cliente = obterCliente();  
37.                   clienteDAO.alterarCliente(cliente);  
38.               }  
39.          }  
40.       }  
41.    }  
42.   
43.    public Cliente obterCliente(){  
44.       Cliente cliente = new Cliente();   
45.       // Aqui deve-se obter todos os dados contidos nos componentes  
46.       //      e preencher o objeto cliente.  
47.       // Exemplo: cliente.setNomCli(guiCli.tfnomcli.getText());  
48.       return cliente;  
49.    }  
50.   
51.    public void mostrarCliente(Cliente cliente){  
52.       // Aqui deve-se obter todos os dados contidos no objeto cliente  
53.       //      e preencher os componentes da interface gráfica  
54.       // Exemplo: guiCli.tfnomcli.setText(cliente.getNomCli());  
55.    }  
56. }  
A classe ClienteGUI.java contém apresentação da interface gráfica para tratar os dados
do Cliente.
Veja o exemplo:

Veja o trecho do código:

texto planocopiar para memóriaimprimir?

1. public class ClienteGUI extends JInternalFrame {  
2.    // declarar os componentes da interface  
3.   
4.    public ClienteGUI() {   
5.       // criar a interface gráfica  
6.    }  
7.   
8.    public void adicionarOuvinteCliente1 (ActionListener ouvinte) {  
9.       // adicionar os ouvintes aos botões  
10.       // Ex.: this.bIncCli.addActionListener(ouvinte);  
11.    }  
12.   
13.    public void limparCampos() {  
14.       // comandos para limpar os componentes  
15.    }  
16. }  

O menu está no JDesktopPane e as demais janelas serão JInternalFrame.

A classe que controla Cliente (IncluirClienteController.java) também precisa da classe
Cliente.java que tem a definição dos atributos e dos métodos acessores (get) e
modificadores (set).
Veja parte do código:
texto planocopiar para memóriaimprimir?

1. public class Cliente {  
2.    // declare todos os atributos como private  
3.    private int codcli;  
4.    private String nomcli;  
5.   
6.    public Cliente() {  
7.       super();  
8.    }  
9.   
10.    public Cliente (int codcli, String nomcli){  
11.       super();  
12.       this.codcli = codcli;  
13.       this.nomcli = nomcli;  
14.    }  
15.      
16.    public int getCodCli(){  
17.       return this.codcli;  
18.    }  
19.    
20.    public String getNomCli(){  
21.       return this.nomcli;  
22.    }  
23.   
24.    public void setCodCli(int codcli) {  
25.       this.codcli = codcli;  
26.    }  
27.    
28.    public void setNomCli(String nomcli) {  
29.       this.nomcli = nomcli;  
30.    }  
31. }  

A classe ClienteDAO.java (Data Access Object) trata das rotinas de inclusão, exclusão,
alteração e consulta, ou seja, trabalha diretamente com a fonte de dados (o BD). Todos
os seus métodos realizarão a conexão com o Banco de Dados, sendo assim, precisam
instanciar um objeto da classe FactoryConnection.java.
Ex.: Connection con = FactoryConnection.getConnection();
texto planocopiar para memóriaimprimir?

1. public class ClienteDAO {  
 2.    public void incluirCliente(Cliente cliente) {  
3.       // tratar inclusão  
4.    }  
5.    
6.    public Cliente consultarCliente() {  
7.       // tratar consulta  
8.       return cliente;  
9.    }  
10.    
11.    public void alterarCliente(Cliente cliente) {  
12.       // tratar alteração  
13.    }  
14.   
15.    public void excluirCliente(String strcod) {  
16.       // tratar exclusão  
17.    }  
18. }  

Para maiores detalhes, clique aqui e acesse o Fórum Programação Java - Dicas que
contém detalhes da classe ClienteDAO.

A classe FactoryConnection apresenta a conexão com o Banco de Dados, que neste

exemplo será o H2.
texto planocopiar para memóriaimprimir?

1. public class FactoryConnection {  
2.    public static Connection getConnection(){  
3.       Connection con = null;  
4.       try {  
5.            Class.forName("org.h2.Driver");  
6.            String url = "jdbc:h2:tcp://localhost:9092/C:/DB/Banco";  
7.            String user = "admin";  
8.            String password = "senha";  
9.            con = DriverManager.getConnection(url, user, password);    
10.       } catch (Exception e){  
11.            e.printStackTrace();  
12.       }  
13.       return con;  
14.    }  
15. }  

Trabalhando dessa forma, suas classes ficam menores e bem dividas por assunto!
O códigos foram didaticamente apresentados! Portanto, use sua criatividade e melhore-
os!

Read more: Java - Criando uma aplicação em 3 camadas (MVC) | Blog Brasil
Acadêmico http://blog.brasilacademico.com/2008/11/java-criando-uma-aplicao-em-3-
camadas.html#ixzz19qTeg6Oq