InformáticaCSI: Java Desktop

Vamos retomar o projeto de Cadastro de Clientes, criando uma tela de Login. E você pode aproveitar em outros projetos que você desenvolveu.

E se você ainda não criou o projeto de Cadastro, siga a série Java Desktop - Cadastro CRUD desde blog. Confira neste link.

Vamos ver três ajustes: criar uma tabela no banco de dados, a classe Dao para o cadastro de novos acessos, criar uma classe JFrame para a tela/janela de Login e alterar a classe Principal, que é a classe main.

Tabela Login no Banco de Dados

Adicione uma nova tabela à base de dados cadastrocliente criada - veja nesta publicação para recordar se precisar.

Na opção de coluna, coloque para adicionar 4 colunas: a coluna do id - chave primária, operador (O nome da pessoa que irá acessar - para facilitar a identificação), nome e senha (os três campos tipo VARCHAR).

Lembrando de salvar a tabela clicando no botão Guardar no canto inferior direito.

Classe LoginDAO

Para fazer a validação do nome e senha precisamos criar a classe Dao, que fará a conexão com o banco, verificando os dados dos campos nome e senha, comparando com os dados digitados na janela de Login.

Crie a classe dentro do pacote dao, mantendo o padrão MVC, da mesma forma feita na parte 4 da série de publicações Java Desktop, Cadastro CRUD, neste link.

Para manter um padrão de nomenclatura, nomeie a classe como LoginDao.

A validação será feita com um método booleano - que retorna true ou false, verdadeiro ou falso, método que é executado ao clicar no botão Entrar da janela de Login, comparando os dados digitados nos campos nome e senha com os campos respectivos na tabela Login do banco de dados.

Confira o código abaixo com os comentários:

1: package br.com.cliente.dao; 
2: import java.sql.PreparedStatement; 
3: import java.sql.ResultSet; 
4: import java.sql.SQLException; 
5: import br.com.cliente.util.Conector; 
6: public class LoginDao { 
7: public boolean acessoLogin(String nome, String senha ) { 
8: </code><code style="word-wrap: normal;">//Método booleano com dois argumentos para autenticar nome e senha do usuário; </code><code style="word-wrap: normal;"> 
9: String sql = "select * from Login where nome=? and senha=?"; 
10: </code><code style="word-wrap: normal;">//Cria variável tipo String com comando de seleção SQL dos campos nome e senha;</code><code style="word-wrap: normal;"> 
11: boolean check = false; //Cria variável boolean abribuindo o valor false; 
12: try { 
13: PreparedStatement ps = Conector.getConexao().prepareStatement(sql); 
14: </code><code style="word-wrap: normal;"> //Faz a conexão ao banco e executa a variável sql (comando select) e atribui 
15: //à variável ps do PreparedStatement; </code><code style="word-wrap: normal;">
16: ps.setString(1, nome); 
17: </code><code style="word-wrap: normal;"> //Seta à String nome os dados do campo nome da tabela Login do banco; </code><code style="word-wrap: normal;">
18: ps.setString(2, senha); 
19: </code><code style="word-wrap: normal;">//Seta à String senha os dados do campo senha da tabela Login do banco; </code><code style="word-wrap: normal;"> 
20: ResultSet rs = ps.executeQuery(); 
21: </code><code style="word-wrap: normal;"> //Executa o comando, listando os dados de nome e senha cadastrados no banco; </code><code style="word-wrap: normal;">
22: if (rs.next()) { //Condicional para verificar se os valores abribuídos aos argumentos 
23: </code><code style="word-wrap: normal;">//String nome e senha do método correspondem ou não ao conteúdo de nome e senha 
24: //no banco de dados; </code><code style="word-wrap: normal;">
25: check = true; 
26: </code><code style="word-wrap: normal;">//Se correspondem, o método responde verdadeiro - true; </code><code style="word-wrap: normal;">
27: } 
28: } catch (SQLException e) { 
29: </code><code style="word-wrap: normal;">// TODO Auto-generated catch block </code><code style="word-wrap: normal;"> 
30: e.printStackTrace(); 
31: } 
32: return check; 
33: </code><code style="word-wrap: normal;">//Retorna a variável boolean check; </code><code style="word-wrap: normal;"> 
34: } 
35: }

Classe JFrame - Tela de Login

Crie a classe JFrame no pacote view - reveja esta publicação para mais detalhes. Pronta a classe Dao, fechamos o login de acesso criando a janela onde os dados são digitados e, chamando o método acessoLogin da Dao, fazendo a validação. Lembrando que a classe JFrame está detalhada na publicação Java Desktop, Cadastro CRUD -5, neste link.

Para o formulário de Login, nomeei como LoginCadastro. Pode ser FormLogin ou como preferir.

O código deverá ficar como na sequência abaixo. Acompanhe os comentários nas rotinas de validação dos dados dos campos nome e senha, quando pressionado Enter no teclado após digitar a senha, quando clicar no botão Entrar ou pressionar a tecla Enter, quando o foco de tabulação ou seleção estiver no botão Entrar:

1:  package br.com.cliente.view;  
2:    
3:  import java.awt.BorderLayout;  
4:  import java.awt.Color;  
5:  import java.awt.EventQueue;  
6:  import java.awt.Font;  
7:  import java.awt.SystemColor;  
8:  import java.awt.event.ActionEvent;  
9:  import java.awt.event.ActionListener;  
10:  import java.awt.event.KeyAdapter;  
11:  import java.awt.event.KeyEvent;  
12:    
13:  import javax.swing.ImageIcon;  
14:  import javax.swing.JButton;  
15:  import javax.swing.JFrame;  
16:  import javax.swing.JLabel;  
17:  import javax.swing.JOptionPane;  
18:  import javax.swing.JPanel;  
19:  import javax.swing.JPasswordField;  
20:  import javax.swing.JTextField;  
21:  import javax.swing.border.EmptyBorder;  
22:    
23:  import br.com.cliente.dao.LoginDao;  
24:  import br.com.cliente.view.LoginCadastro;  
25:    
26:    
27:  public class LoginCadastro extends JFrame {  
28:    
29:       private JPanel contentPane;  
30:       private JTextField txtNome;  
31:       private JPasswordField txtSenha;  
32:         
33:    
34:       public LoginCadastro() {  
35:            setBackground(new Color(189, 183, 107));  
36:            setResizable(false);  
37:            setTitle("Cadastro de Clientes - Acesso");  
38:            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
39:            setBounds(100, 100, 452, 205);  
40:            contentPane = new JPanel();  
41:            contentPane.setBackground(Color.LIGHT_GRAY);  
42:            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));  
43:            setContentPane(contentPane);  
44:            contentPane.setLayout(null);  
45:            this.setLocationRelativeTo(null);  
46:              
47:            JLabel lblNewLabel = new JLabel("Nome:");  
48:            lblNewLabel.setFont(new Font("Ubuntu", Font.BOLD, 14));  
49:            lblNewLabel.setForeground(SystemColor.desktop);  
50:            lblNewLabel.setBounds(230, 51, 86, 20);  
51:            contentPane.add(lblNewLabel);  
52:              
53:            JLabel lblSenha = new JLabel("Senha:");  
54:            lblSenha.setForeground(Color.RED);  
55:            lblSenha.setFont(new Font("Ubuntu", Font.BOLD, 14));  
56:            lblSenha.setBounds(230, 84, 70, 15);  
57:            contentPane.add(lblSenha);  
58:              
59:            txtNome = new JTextField();  
60:            txtNome.setFont(new Font("Ubuntu", Font.BOLD, 14));  
61:            txtNome.setForeground(SystemColor.desktop);  
62:            txtNome.setBounds(312, 52, 114, 19);  
63:            contentPane.add(txtNome);  
64:            txtNome.setColumns(10);  
65:              
66:            txtSenha = new JPasswordField();  
67:            txtSenha.addKeyListener(new KeyAdapter() {  
68:              //Programa evento ao pressionar tecla determinada;  
69:                 @Override  
70:                 public void keyPressed(KeyEvent arg0) {  
71:                     //Método para programar evento ao pressionar tecla; </span></code><code style="color: black; word-wrap: normal;"> 
72:                      if(arg0.getKeyCode()==KeyEvent.VK_ENTER){  
73:                        //Se a tecla Enter por pressionada com o campo de senha selecionado,   
74:                        //dispara evento programado abaixo (autenticação); </span></code><code style="color: black; word-wrap: normal;"> 
75:                           String pass = new String(txtSenha.getPassword()).trim();  
76:                           //Cria variável String onde é gravado a senha digitada no campo senha;  </span></code><code style="color: black; word-wrap: normal;">
77:                           LoginDao dao = new LoginDao();  
78:                           //Instância da classe LoginDao;  </span></code><code style="color: black; word-wrap: normal;">
79:                           if(dao.acessoLogin(txtNome.getText(), pass)){  
80:                                //Condicional para validar nome e senha, chamando o método  
81:                                //acessoLogin da classe LoginDao;  </span></code><code style="color: black; word-wrap: normal;">
82:                                new FormCliente().setVisible(true);  
83:                                //Abre o formulário de cliente caso o nome e senha estejam corretos;  </span></code><code style="color: black; word-wrap: normal;">
84:                                LoginCadastro ls = new LoginCadastro();  
85:                                ls.dispose();  
86:                                //Fecha a janela de Login; </span></code><code style="color: black; word-wrap: normal;"> 
87:                           }else{  
88:                                JOptionPane.showMessageDialog(null, "Nome e/ou senha invalidos...");  
89:                                //Caso o nome e/ou senha não conferem, abre diálogo com mensagem;  </span></code><code style="color: black; word-wrap: normal;">
90:                           }  
91:                      }  
92:                 }  
93:            });  
94:            txtSenha.setBounds(312, 83, 114, 19);  
95:            contentPane.add(txtSenha);  
96:              
97:            JButton btnEntrar = new JButton("Entrar");  
98:            btnEntrar.addKeyListener(new KeyAdapter() {  
99:                 @Override  
100:                 public void keyPressed(KeyEvent arg0) {  
101:                      if(arg0.getKeyCode()==KeyEvent.VK_ENTER){  
102:                           //Se a tecla Enter por pressionada quando o botão Entrar estiver selecionado,   
103:                           //dispara evento programado abaixo (autenticação - semelhante ao campo de senha);  </span></code><code style="color: black; word-wrap: normal;">
104:                           String pass = new String(txtSenha.getPassword()).trim();  
105:                           LoginDao dao = new LoginDao();  
106:                           if(dao.acessoLogin(txtNome.getText(), pass)){  
107:                                new FormCliente().setVisible(true);  
108:                                LoginCadastro ls = new LoginCadastro();  
109:                                ls.dispose();  
110:                           }else{  
111:                                JOptionPane.showMessageDialog(null, "Nome e/ou senha invalidos...");  
112:                           }  
113:                 }  
114:                 }  
115:            });  
116:            btnEntrar.setForeground(new Color(0, 128, 0));  
117:            btnEntrar.setFont(new Font("Arial Black", Font.PLAIN, 12));  
118:            btnEntrar.requestFocus();  
119:            btnEntrar.addActionListener(new ActionListener() {  
120:                 public void actionPerformed(ActionEvent arg0) {  
121:                     //Se clicar no botão Entrar, dispara evento programado abaixo (autenticação - idem);  </span></code><code style="color: black; word-wrap: normal;">
122:                      String pass = new String(txtSenha.getPassword()).trim();  
123:                      LoginDao dao = new LoginDao();  
124:                      if(dao.acessoLogin(txtNome.getText(), pass)){  
125:                           new FormCliente().setVisible(true);  
126:                           LoginCadastro ls = new LoginCadastro();  
127:                           ls.dispose();  
128:                      }else{  
129:                           JOptionPane.showMessageDialog(null, "Nome e/ou senha invalidos...");  
130:                      }  
131:                 }  
132:            });  
133:            btnEntrar.setBounds(312, 121, 95, 25);  
134:            contentPane.add(btnEntrar);  
135:              
136:            JLabel lblNewLabel_1 = new JLabel("");  
137:            lblNewLabel_1.setIcon(new ImageIcon(LoginCadastro.class.getResource("/img/KeyChainAccess_37052.png")));  
138:            lblNewLabel_1.setBounds(47, 27, 128, 119);  
139:            contentPane.add(lblNewLabel_1);  
140:       }  
141:    
142:  }

A rotina de validação presente no código fica no método actionPerformed, que pode ser criado no windowsbuilder, pressionando o botão direito do mouse no campo de texto ou botão da janela. Também pode ser feito como visto na parte final da sequência de publicações Java Desktop - Cadastro CRUD, implementando Action Listener e, manualmente, inserindo os códigos de validação no método actionPerformed, se preferir:

A imagem da chave é ilustrativa. Você pode colocar a imagem que preferir, com o porém de que as dimensões da mesma deve ser de 128 x 128 pixels. Coloque a imagem de sua preferência na pasta img do projeto, copiando e colando - veja o título 2 desta publicação. Caso a nova imagem não esteja aparecendo no projeto, tente a opção Refresh com o botão direito sobre a pasta img:

Caso o recurso Refresh não funcione, simplesmente copie e cole a imagem na pasta img, dentro do Eclipse, como na imagem acima.

Classe Principal

Finalizando, para o sistema pedir login de acesso ele deve iniciar "chamando" a janela de Login. A classe Principal, a classe com o método main, originalmente inicia direto o formulário de cadastro de clientes, FormCliente. No seu projeto deve estar assim:

Basta então alterar para que o sistema "chame" a janela de Login, ou seja, a classe LoginCadastro.

Em seguida, pode excluir o import de FormCliente, que não terá mais utilidade.

Testando o Sistema

Até aqui, a criação de usuários só pode ser feita pelo banco de dados, ou seja, pelo phpMyAdmin.

Para testar, crie um novo usuário selecionando a tabela login e a aba Insere no phpMyAdmin, clicando em Executar para salvar os dados:

Execute o sistema no Eclipse clicando na seta verde na barra de ferramentas superior, ou pelo menu Run (com a classe Principal selecionada). Na imagem abaixo, um exemplo de quando os dados de login estão corretos:

Para conferir quando é digitado um nome ou senha inválidos, veja se aparece a Mensagem de erro JOptionPane do código, como na imagem abaixo:

Na próxima publicação veremos outro aprimoramento, para poder inserir novos acessos ao sistema, dentro do próprio sistema, ao invés de inserir direto pelo gerenciador de banco de dados phpMyAdmin.

22 de set. de 2018

Java Desktop - Login de acesso