sábado, 1 de julho de 2017

Java Desktop - Cadastro de logins

Eclipse Java JFrame

Após criar uma janela de Login para acessar o sistema mediante nome e senha, podemos criar um formulário para cadastrar novos logins, ou novos usuários que podem acessar o sistema. 

Isso quer dizer criar um novo formulário, seguindo os mesmos passos da série Java Desktop - Cadastro CRUD: criar uma classe no pacote bean; implementar a interface Dao na classe LoginDao, do pacote dao; LoginCT no pacote controle e criar a classe JFrame para o formulário. 

Finalmente, para abrir o formulário de Login, acrescentar um botão no JFrame FormCliente.

CLASSE BEAN LOGIN

No pacote bean, precisamos da classe onde estarão os atributos e métodos assessores. Na publicação Java Desktop, Cadastro CRUD 2 - MVC está, passo a passo, a criação dos pacotes e parte das classes.

Da mesma forma vista na classe Cliente no pacote bean, crie os atributos privados que corresponde às colunas da tabela Login no banco de dados: id, operador, nome e senha:
1:  package br.com.cliente.bean;  
2:    
3:  public class Login {  
4:       private Integer id;  
5:       private String operador;  
6:       private String nome;  
7:       private String senha;  
8:         
9:       public Integer getId() {  
10:            return id;  
11:       }  
12:       public void setId(Integer id) {  
13:            this.id = id;  
14:       }  
15:       public String getOperador() {  
16:            return operador;  
17:       }  
18:       public void setOperador(String operador) {  
19:            this.operador = operador;  
20:       }  
21:       public String getNome() {  
22:            return nome;  
23:       }  
24:       public void setNome(String nome) {  
25:            this.nome = nome;  
26:       }  
27:       public String getSenha() {  
28:            return senha;  
29:       }  
30:       public void setSenha(String senha) {  
31:            this.senha = senha;  
32:       }  
33:         
34:       @Override  
35:       public String toString() {  
36:            // TODO Auto-generated method stub  
37:            return getOperador();  
38:       }  
39:  }  

INTERFACE DAO NA CLASSE LOGINDAO

Abra a classe LoginDao criada na publicação anterior. 

Como feito na classe ClienteDao, implemente a interface Dao, como no destaque em vermelho no código abaixo. Veja mais detalhes nesta publicação, onde está o código de ClienteDao com comentários em cada método da interface Dao.
1:  package br.com.cliente.dao;  
2:    
3:  import java.sql.PreparedStatement;  
4:  import java.sql.ResultSet;  
5:  import java.sql.SQLException;  
6:  import java.util.ArrayList;  
7:  import java.util.List;  
8:    
9:  import br.com.cliente.bean.Login;  
10:  import br.com.cliente.util.Conector;  
11:  import br.com.cliente.util.Dao;  
12:    
13:  public class LoginDao implements Dao{  
14:         
15:  public boolean acessoLogin(String nome, String senha ) {  
16:              
17:            String sql = "select * from Login where nome=? and senha=?";  
18:    
19:            boolean check = false;  
20:            try {  
21:                 PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
22:                 ps.setString(1, nome);  
23:                 ps.setString(2, senha);  
24:                 ResultSet rs = ps.executeQuery();  
25:    
26:                 if (rs.next()) {  
27:                      check = true;  
28:                 }  
29:            } catch (SQLException e) {  
30:                 // TODO Auto-generated catch block  
31:                 e.printStackTrace();  
32:            }  
33:            return check;  
34:       }  
35:    
36:  @Override  
37:  public void delete(Object arg0) {  
38:       Login lg = (Login) arg0;  
39:       String sql = "delete from Login where id=?";  
40:       try {  
41:            PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
42:            ps.setInt(1, lg.getId());  
43:            ps.equals(lg);  
44:       } catch (SQLException e) {  
45:            // TODO Auto-generated catch block  
46:            e.printStackTrace();  
47:       }  
48:         
49:  }  
50:    
51:  @Override  
52:  public void insert(Object arg0) {  
53:       Login lg = (Login) arg0;  
54:       String sql = "insert into Login (operador,nome,senha) values (?,?,?)";  
55:       try {  
56:            PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
57:            ps.setString(1, lg.getOperador());  
58:            ps.setString(2, lg.getNome());  
59:            ps.setString(3, lg.getSenha());  
60:            ps.execute();  
61:       } catch (SQLException e) {  
62:            // TODO Auto-generated catch block  
63:            e.printStackTrace();  
64:       }  
65:         
66:  }  
67:    
68:  @Override  
69:  public List select() {  
70:       List<Login> list = new ArrayList<Login>();  
71:       String sql = "select * from Login";  
72:       try {  
73:            PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
74:            ResultSet rs = ps.executeQuery();  
75:            while(rs.next()){  
76:                 Login ac = new Login();  
77:                 ac.setId(rs.getInt("id"));  
78:                 ac.setOperador(rs.getString("operador"));  
79:                 ac.setNome(rs.getString("nome"));  
80:                 ac.setSenha(rs.getString("senha"));  
81:                 list.add(ac);  
82:            }  
83:       } catch (SQLException e) {  
84:            // TODO Auto-generated catch block  
85:            e.printStackTrace();  
86:       }  
87:       return list;  
88:  }  
89:    
90:  @Override  
91:  public Object select(int arg0) {  
92:       Login lg = new Login();  
93:       String sql = "select * from Login where id=?";  
94:       try {  
95:            PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
96:            ResultSet rs = ps.executeQuery();  
97:            while(rs.next()){  
98:                   
99:                 lg.setOperador(rs.getString("operador"));  
100:                 lg.setNome(rs.getString("nome"));  
101:                 lg.setSenha(rs.getString("senha"));  
102:                   
103:                   
104:            }  
105:       } catch (SQLException e) {  
106:            // TODO Auto-generated catch block  
107:            e.printStackTrace();  
108:       }  
109:       return lg;  
110:         
111:  }  
112:    
113:  @Override  
114:  public void update(Object arg0) {  
115:       Login lg = (Login) arg0;  
116:       String sql = "update Acesso set operador=?,nome=?,senha=? where id=?";  
117:       try {  
118:            PreparedStatement ps = Conector.getConexao().prepareStatement(sql);  
119:            ps.setString(1, lg.getOperador());  
120:            ps.setString(2, lg.getNome());  
121:            ps.setString(3, lg.getSenha());  
122:            ps.setInt(4, lg.getId());  
123:            ps.execute();  
124:       } catch (SQLException e) {  
125:            // TODO Auto-generated catch block  
126:            e.printStackTrace();  
127:       }  
128:         
129:  }  
130:  }  

LOGINCT NO PACOTE CONTROLE

Novamente, esta classe tem o mesmo funcionamento da classe ClienteCT, vista em detalhes na última parte da série Java Desktop, Cadastro CRUD

Crie agora uma nova classe no pacote controle - LoginCT.

É a classe que "chama" os métodos de LoginDao, atribuindo o resultado destes a um objeto Login (classe do pacote bean, destacada em azul no código abaixo).
1:  package br.com.cliente.controle;  
2:    
3:  import java.util.List;  
4:    
5:  import br.com.cliente.bean.Login;  
6:  import br.com.cliente.dao.LoginDao;  
7:    
8:  public class LoginCT {  
9:         
10:       public void insert(Login lg){  
11:            LoginDao dao = new LoginDao();  
12:            dao.insert(lg);  
13:       }  
14:         
15:       public void update(Login lg){  
16:            LoginDao dao = new LoginDao();  
17:            dao.update(lg);  
18:       }  
19:         
20:       public void delete(Login lg){  
21:            LoginDao dao = new LoginDao();  
22:            dao.delete(lg);  
23:       }  
24:         
25:       public Login select(int i){  
26:            LoginDao dao = new LoginDao();  
27:            Login lg = (Login) dao.select();  
28:            return lg;  
29:       }  
30:         
31:       public List<Login> select(){  
32:            LoginDao dao = new LoginDao();  
33:            List<Login> lg = dao.select();  
34:            return lg;  
35:       }  
36:  }  

FORMULÁRIO JFRAME DE LOGIN

Todos os códigos aqui podem ser simplesmente copiados e colados em suas classes respectivas. Porém, recomendo para fins didáticos a digitação linha a linha.

Com mais o código abaixo o formulário estará completo e funcionando, podendo criar novos usuários com nome e senha para acessar o sistema, excluir, alterar ou consultar na pesquisa.

Em Java Desktop, Cadastro CRUD - 5: JFrame, neste link, está detalhado a criação da classe FormCliente. A lógica é a mesma, apenas alterando o nome dos campos e classes.

Criei com o nome LoginNovo, porém pode criar com outro nome se preferir.
1:  package br.com.cliente.view;  
2:    
3:  import java.awt.Color;  
4:  import java.awt.Font;  
5:  import java.awt.SystemColor;  
6:  import java.awt.event.ActionEvent;  
7:  import java.awt.event.ActionListener;  
8:  import java.util.List;  
9:    
10:  import javax.swing.ImageIcon;  
11:  import javax.swing.JButton;  
12:  import javax.swing.JComboBox;  
13:  import javax.swing.JFrame;  
14:  import javax.swing.JLabel;  
15:  import javax.swing.JOptionPane;  
16:  import javax.swing.JPanel;  
17:  import javax.swing.JPasswordField;  
18:  import javax.swing.JTextField;  
19:  import javax.swing.border.EmptyBorder;  
20:    
21:  import br.com.cliente.bean.Login;  
22:  import br.com.cliente.controle.LoginCT;  
23:  import br.com.cliente.view.LoginNovo;  
24:    
25:  public class LoginNovo extends JFrame implements ActionListener {  
26:    
27:       private JPanel contentPane;  
28:       private JTextField txtNome;  
29:       private JPasswordField txtSenha;  
30:       private JButton btnSalvar;  
31:       private JButton btnAlterar;  
32:       private JButton btnExcluir;  
33:       private JButton btnSelecionar;  
34:    
35:       private JComboBox cbLogin;  
36:       private JLabel lblOperador;  
37:       private JTextField txtOperador;  
38:       private JButton btnLimpar;  
39:       private JTextField txtID;  
40:       private JLabel lblId;  
41:    
42:       public void limpaTela() {  
43:            this.txtOperador.setText("");  
44:            this.txtNome.setText("");  
45:            this.txtSenha.setText("");  
46:            this.txtID.setText(null);  
47:       }  
48:    
49:       public void carregaLista() {  
50:            LoginCT sbc = new LoginCT();  
51:            List<Login> list = sbc.select();  
52:            cbLogin.removeAllItems();  
53:            for (Login login : list) {  
54:                 cbLogin.addItem(login);  
55:            }  
56:       }  
57:    
58:       public Login montaLogin() { // Pega dos dados digitados nos campos do  
59:            // formulário e atribui ao objeto  
60:            Login lg = new Login();  
61:            lg.setOperador(this.txtOperador.getText());  
62:            lg.setNome(this.txtNome.getText());  
63:              
64:            lg.setSenha(this.txtSenha.getText());  
65:    
66:            if (this.txtID.getText() != null && !this.txtID.getText().equals("")) {  
67:                 lg.setId(Integer.parseInt(this.txtID.getText()));  
68:            }  
69:            return lg;  
70:    
71:       }  
72:    
73:       public void setAcesso(Login lg) { // Preenche formulário do Usuario  
74:                                                    // selecionado ao pressionar btnSelect  
75:            this.txtOperador.setText(lg.getOperador());  
76:            this.txtNome.setText(lg.getNome());  
77:            this.txtSenha.setText(lg.getSenha());  
78:    
79:            if (lg.getId() != null && lg.getId() > 0) {  
80:                 this.txtID.setText(lg.getId().toString());  
81:            }  
82:       }  
83:    
84:       public LoginNovo() {  
85:            setTitle("Cadastro de Clientes - Acesso");  
86:            setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);  
87:            setBounds(100, 100, 450, 300);  
88:            contentPane = new JPanel();  
89:            contentPane.setBackground(Color.LIGHT_GRAY);  
90:            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));  
91:            setContentPane(contentPane);  
92:            contentPane.setLayout(null);  
93:    
94:            JLabel lblNome = new JLabel("Nome:");  
95:            lblNome.setFont(new Font("Arial Black", Font.BOLD, 12));  
96:            lblNome.setForeground(SystemColor.desktop);  
97:            lblNome.setBounds(95, 127, 70, 15);  
98:            contentPane.add(lblNome);  
99:    
100:            txtNome = new JTextField();  
101:            txtNome.setBounds(183, 125, 146, 19);  
102:            contentPane.add(txtNome);  
103:            txtNome.setColumns(10);  
104:    
105:            JLabel lblSenha = new JLabel("Senha:");  
106:            lblSenha.setFont(new Font("Arial Black", Font.PLAIN, 12));  
107:            lblSenha.setForeground(new Color(165, 42, 42));  
108:            lblSenha.setBounds(95, 153, 70, 15);  
109:            contentPane.add(lblSenha);  
110:    
111:            txtSenha = new JPasswordField();  
112:            txtSenha.setBounds(183, 151, 146, 19);  
113:            contentPane.add(txtSenha);  
114:            txtSenha.setColumns(10);  
115:    
116:            btnSalvar = new JButton("");  
117:            btnSalvar.setIcon(new ImageIcon(LoginNovo.class.getResource("/img/save.png")));  
118:            btnSalvar.setFont(new Font("Ubuntu", Font.BOLD, 14));  
119:            btnSalvar.setForeground(new Color(0, 100, 0));  
120:            btnSalvar.setBounds(95, 179, 32, 25);  
121:            btnSalvar.addActionListener(this);  
122:            btnSalvar.setActionCommand("salvar");  
123:            contentPane.add(btnSalvar);  
124:    
125:            btnAlterar = new JButton("");  
126:            btnAlterar.setIcon(new ImageIcon(LoginNovo.class.getResource("/img/edit.png")));  
127:            btnAlterar.setForeground(new Color(160, 82, 45));  
128:            btnAlterar.setFont(new Font("Ubuntu", Font.BOLD, 14));  
129:            btnAlterar.setBounds(139, 179, 32, 25);  
130:            btnAlterar.addActionListener(this);  
131:            btnAlterar.setActionCommand("alterar");  
132:            contentPane.add(btnAlterar);  
133:    
134:            btnExcluir = new JButton("");  
135:            btnExcluir.setIcon(new ImageIcon(LoginNovo.class.getResource("/img/delete.png")));  
136:            btnExcluir.setForeground(Color.RED);  
137:            btnExcluir.setFont(new Font("Dialog", Font.BOLD, 12));  
138:            btnExcluir.setBounds(225, 179, 32, 25);  
139:            btnExcluir.addActionListener(this);  
140:            btnExcluir.setActionCommand("excluir");  
141:            contentPane.add(btnExcluir);  
142:    
143:            cbLogin = new JComboBox();  
144:            cbLogin.setBounds(183, 37, 146, 20);  
145:            contentPane.add(cbLogin);  
146:    
147:            JLabel lblPesquisar = new JLabel("Pesquisar:");  
148:            lblPesquisar.setFont(new Font("Arial Black", Font.BOLD, 12));  
149:            lblPesquisar.setBounds(95, 40, 80, 14);  
150:            contentPane.add(lblPesquisar);  
151:    
152:            btnSelecionar = new JButton("");  
153:            btnSelecionar.setIcon(new ImageIcon(LoginNovo.class.getResource("/img/search.png")));  
154:            btnSelecionar.setFont(new Font("Dialog", Font.BOLD, 12));  
155:            btnSelecionar.setBounds(339, 36, 32, 25);  
156:            btnSelecionar.addActionListener(this);  
157:            btnSelecionar.setActionCommand("selecionar");  
158:            contentPane.add(btnSelecionar);  
159:    
160:            lblOperador = new JLabel("Operador:");  
161:            lblOperador.setFont(new Font("Arial Black", Font.BOLD, 12));  
162:            lblOperador.setBounds(95, 100, 80, 14);  
163:            contentPane.add(lblOperador);  
164:    
165:            txtOperador = new JTextField();  
166:            txtOperador.setBounds(183, 98, 146, 20);  
167:            contentPane.add(txtOperador);  
168:            txtOperador.setColumns(10);  
169:    
170:            btnLimpar = new JButton("");  
171:            btnLimpar.setIcon(new ImageIcon(LoginNovo.class.getResource("/img/clean.png")));  
172:            btnLimpar.setForeground(new Color(0, 0, 255));  
173:            btnLimpar.setFont(new Font("Dialog", Font.BOLD, 14));  
174:            btnLimpar.setActionCommand("alterar");  
175:            btnLimpar.setBounds(183, 179, 32, 25);  
176:            btnLimpar.addActionListener(this);  
177:            btnLimpar.setActionCommand("limpar");  
178:            contentPane.add(btnLimpar);  
179:    
180:            txtID = new JTextField();  
181:            txtID.setEditable(false);  
182:            txtID.setBounds(183, 68, 41, 20);  
183:            contentPane.add(txtID);  
184:            txtID.setColumns(10);  
185:    
186:            lblId = new JLabel("ID:");  
187:            lblId.setFont(new Font("Arial Black", Font.BOLD, 12));  
188:            lblId.setBounds(95, 70, 50, 14);  
189:            contentPane.add(lblId);  
190:    
191:            this.carregaLista();  
192:       }  
193:    
194:       @Override  
195:       public void actionPerformed(ActionEvent e) {  
196:            if (e.getActionCommand().equals(this.btnSalvar.getActionCommand())) {  
197:                 Login s = this.montaLogin();  
198:                 LoginCT lct = new LoginCT();  
199:                 lct.insert(s);  
200:                 JOptionPane.showMessageDialog(null, "Login cadastrado.");  
201:                 this.limpaTela();  
202:                 this.carregaLista();  
203:    
204:            } else if (e.getActionCommand().equals(this.btnAlterar.getActionCommand())) {  
205:                 String message = "Confirma edição do login selecionada?";  
206:                 String title = "Confirmação";  
207:                 int reply = JOptionPane.showConfirmDialog(null, message, title, JOptionPane.YES_NO_CANCEL_OPTION);  
208:                 if (reply == JOptionPane.YES_OPTION) {  
209:                      Login s = this.montaLogin();  
210:                      LoginCT lct = new LoginCT();  
211:                      lct.update(s);  
212:                      this.limpaTela();  
213:                      this.carregaLista();  
214:    
215:                 }  
216:    
217:            } else if (e.getActionCommand().equals(this.btnExcluir.getActionCommand())) {  
218:                 String message = "Confirma exclusão do login selecionado?";  
219:                 String title = "Confirmação";  
220:                 int reply = JOptionPane.showConfirmDialog(null, message, title, JOptionPane.YES_NO_CANCEL_OPTION);  
221:                 if (reply == JOptionPane.YES_OPTION) {  
222:                      Login s = this.montaLogin();  
223:                      LoginCT lct = new LoginCT();  
224:                      lct.delete(s);  
225:                      this.limpaTela();  
226:                      this.carregaLista();  
227:    
228:                 }  
229:            } else if (e.getActionCommand().equals(this.btnLimpar.getActionCommand())) {  
230:                 this.limpaTela();  
231:            } else if (e.getActionCommand().equals(this.btnSelecionar.getActionCommand())) {  
232:                 Login lct = (Login) cbLogin.getSelectedItem();  
233:                 this.setAcesso(lct);  
234:            }  
235:    
236:       }  
237:  }  
238:    
Na próxima publicação veremos a implementação de relatórios para impressão. Não perca!

Escreva nos comentários, clique em curtir, visite a página do Facebook  e compartilhe com seus amigos. Até a próxima!

Nenhum comentário:

Postar um comentário