Ola…Minha classe inicial tinha o resulSet, ao que entendi nos estudos, sempre que é preciso pesquisar no banco dados determinada clausula, preciso utilizar o resulset que me trará os dados solicitados em minha pesquisa. tentei criar o metodo que voce prope, nao sei se essa era sua ideia, mas ainda assim retorna null no println no metdodo public void consultarUsuario(int funcId) da classe UsuarioDAO. meu programa foi reduzido ao abaixo para realizar o teste.
no print vem: o nome do usuario retornado no DAO é: null
public void consultar (){
try {
/*armazena o que no Id digtado no objeto txtUsuarId*/
int funcId= Integer.parseInt(txtUsuarId.getText());
/*instancia a classe funcionarioDAO, e passa o funcId
UsuarioDAO objUserDAO = new UsuarioDAO();
/*executa o metodoDAO e passa o parametro solicitado*/
objUserDAO.consultarUsuario(funcId);
} catch (Exception erro) {
JOptionPane.showMessageDialog(null,"Erro ao cosultar usuario"+ erro);
}
}
public void consultarUsuario(int funcId) {
String sql = "select *from tbUsuarios where iduser=?";
/*chama modulo de conexao*/
conexao = new ModConexaoDAO().conector();
try {
pst = conexao.prepareStatement(sql);
pst.setInt(1, funcId);
UsuarioDto objUsuarioDTO = new UsuarioDto();
rs = pst.executeQuery();
System.out.println(" o nome do usuario retornado no DAO é: " + objUsuarioDTO.getUsuario());
//return rs;
} catch (Exception erro) {
JOptionPane.showMessageDialog(null, "Erro consultar usuario: " + erro);
// return null;
}
}
Certo, mas faltou uma coisa.
Antes do print, vc deve pegar os dados retornados do banco através do resultset:
public UsuarioDto consultarUsuario(int funcId) {
String sql = "SELECT * FROM tbUsuarios WHERE iduser = ?";
// chama modulo de conexao
conexao = new ModConexaoDAO().conector();
try {
pst = conexao.prepareStatement(sql);
pst.setInt(1, funcId);
rs = pst.executeQuery();
// verifica se o resultset possui dados
if (rs.next()) {
UsuarioDto objUsuarioDTO = new UsuarioDto();
objUsuarioDTO.setUsuario(rs.getString("NOME_DA_COLUNA"));
System.out.println(" o nome do usuario retornado no DAO é: " + objUsuarioDTO.getUsuario());
return objUsuarioDTO;
} else {
System.out.println("Nenhum resultado encontrado para o ID " + funcId);
return null;
}
} catch (Exception erro) {
JOptionPane.showMessageDialog(null, "Erro consultar usuario: " + erro);
return null;
} finally {
// feche aqui a conexão, o preparedStatement e o resultSet
}
}
Correto, agora imprimiu o nome do usaurio. A duvida agora é: De inicio, pegava o que o usuario digitava no campo idUsuario getText(), e salvava numa variavel String funcID, em seguida instanciava a DTO e setava no idUser da DTO funcId.
int funcId= Integer.parseInt(txtUsuarId.getText());
UsuarioDto objUserDTO = new UsuarioDto();
objUserDTO.setIduser(funcId);
enviava para a instancia objUsuarioDAO o que havia sido setado em ObjUserDTO.
objUserDAO.consultarUsuario(objUserDTO);
em seguida pegava o resulSet
ResultSet retUsuarioDao = objUserDAO.consultarUsuario(objUserDTO);
recebia na classe TelaUsuario fazendo o if(consultarUsuario.next()) {
preencher os campos nome (txtUsuarNome), fone(txtUsuarFone), login(txtUsuarLogin), senha(txtUsuarSenha), perfil(txtUsuarPerfil)
mas nao retonrava nem preenchia nenhum campo
}
A pergunta é porque nao deu certo passando diretamente para a DTO set() e depois passando como parâmetro para o método consultar com o get()?
agora preciso enviar estes dados para o formulário e preencher os campos dele.
Talvez a forma como vc estava usando o ResultSet também não estava correto. Para pegar os valores do resultSet, vc deve antes chamar o método next para poder “andar” no set de resultados retornados do banco.
Essa agora está mais fácil. Com o UsuarioDto retornado do método consultarUsuario devidamente preenchido, agora basta vc chamar os métodos de cada campo setando o valor neles. Ex.:
txtUsuario.setText(usuarioDto.getUsuario());
Meu formulário está na View,TelaUsuario,as linhas txtUsuario.setText(usuarioDto.getUsuario()); e demais já estavam prontas no programa inicial dentro dessa classe. acredito que preciso conseguir fazer o retorno de consultarUsuario para dentro da view TelaUsuario , pois do modo que está os campos continuam vazios.
private void btnUsuarReadActionPerformed(java.awt.event.ActionEvent evt) {
consultar();
}
public void consultar (){
try {
/*armazena o que no Id digtado no objeto txtUsuarId*/
int funcId= Integer.parseInt(txtUsuarId.getText());
/*Para passar os dados a DTO, e acessar esta classe, precisa instanciar,
atraves doo objeto é que acessamos a classe*/
UsuarioDto objUsuarioDTO = new UsuarioDto();
//objUsuarioDTO.setIduser(funcId);
/*acessa a classe funcionarioDAO, que agora tem os valores de DTO,
para entao exibir o conteudo view*/
UsuarioDAO objUserDAO = new UsuarioDAO();
/*executa o metodoDAO e passa o parametro solicitado*/
objUserDAO.consultarUsuario(funcId);
//UsuarioDAO retornoDAO = new UsuarioDAO();
//consultarUsuario(funcId);
/*recebe o retorno da classe UsuarioDao*/
//ResultSet retUsuarioDao =retornoDAO.consultarUsuario(ResultSet);
//if(retUsuarioDao.next()){
/*Preenchendo os campos do formulario view*/
txtUsuarNome.setText(objUsuarioDTO.getUsuario());
System.out.println("Opa....aqui está o usuario: "+ txtUsuarNome.getText());
txtUsuarFone.setText(objUsuarioDTO.getFone());
System.out.println("Opa....aqui está o telefone dele: "+ txtUsuarFone.getText());
txtUsuarLogin.setText(objUsuarioDTO.getLogin());
txtUsuarSenha.setText(objUsuarioDTO.getSenha());
/*A linha abaixo preenche o combox*/
cboUsuarPerfil.setSelectedItem(objUsuarioDTO.getPerfil());
} catch (Exception erro) {
JOptionPane.showMessageDialog(null,"Erro ao cosultar usuario"+ erro);
}
Para mim o if(rs.next()) teria que estar dentro da view TelaUsuario.Para preencher os campos do formulario.
Não precisa, pois dessa forma que vc está pensando trata-se de uma prática ruim. Que é misturar as camadas. Sua view não precisa conhecer nenhum aspecto do banco de dados. Quanto mais as camadas ficarem isoladas, melhor.
Para usar os dados do usuário na view, basta obter o UsuarioDto retornado pelo método consultarUsuario:
UsuarioDto objUsuarioDTO = objUserDAO.consultarUsuario(funcId);
// aqui vc pega os atributos do usuario e seta nos campos da tela
Essa separação nas camadas é muito importante para facilitar o entendimento do código, manutenção, evolução, testes, etc. Talvez para um sistema pequeno, não faça diferença, mas para sistemas maiores é crucial que o código esteja organizado.
Não há pq a tela conhecer um objeto do tipo ResultSet. Por isso existe o conceito de DAO e Repository, para exatamente abstrair esses objetos e devolver apenas aquilo que a aplicação precisa que, no seu caso, é o UsuarioDto com os dados preenchidos.
Peguei seu código e fiz umas mudanças. Veja o que vc acha:
private void btnUsuarReadActionPerformed(java.awt.event.ActionEvent evt) {
consultar();
}
public void consultar() {
try {
// Obtém o ID do usuário informado na tela
int funcId = Integer.parseInt(txtUsuarId.getText());
// Cria o DAO para recuperar os dados do usuário
UsuarioDAO usuarioDao = new UsuarioDAO();
// Realiza a consulta do usuário pelo ID
UsuarioDto usuario = usuarioDao.consultarUsuario(funcId);
// Verifica se o usuário não foi encontrado
if (usuario == null) {
JOptionPane.showMessageDialog(null, "Usuário não encontrado para o ID " + funcId);
return;
}
// Preenche os campos do formulário para o usuário encontrado
txtUsuarNome.setText(usuario.getUsuario());
txtUsuarFone.setText(usuario.getFone());
txtUsuarLogin.setText(usuario.getLogin());
txtUsuarSenha.setText(usuario.getSenha());
cboUsuarPerfil.setSelectedItem(usuario.getPerfil());
} catch (Exception erro) {
JOptionPane.showMessageDialog(null, "Erro ao cosultar usuario: " + erro);
}
}
Entao…No meu entendimento o caminho seria, pega da view passa set() na dto, dao pega get() da dto executa preparedstament e passa set() novamente para dto, a view pega get() da dto e apresenta ao usuario. este é o conceito que eu estava seguindo. Não é isso?
modifiquei minha view para assim:
public void consultar (){
try {
/*armazena o que no Id digtado no objeto txtUsuarId*/
int funcId= Integer.parseInt(txtUsuarId.getText());
/*Para passar os dados a DTO, e acessar esta classe, precisa instanciar,
atraves doo objeto é que acessamos a classe*/
UsuarioDto objUsuarioDTO = new UsuarioDto();
//objUsuarioDTO.setIduser(funcId);
/*acessa a classe funcionarioDAO, que agora tem os valores de DTO,
para entao exibir o conteudo view*/
UsuarioDAO objUserDAO = new UsuarioDAO();
/*executa o metodoDAO e passa o parametro solicitado*/
objUserDAO.consultarUsuario(funcId);
UsuarioDAO retornoDAO = new UsuarioDAO();
//consultarUsuario(funcId);
/*recebe o retorno da classe UsuarioDao*/
ResultSet retUsuarioDAO = retornoDAO.consultarUsuario(funcId);
if(retUsuarioDAO.next()){
txtUsuarNome.setText(objUsuarioDTO.getUsuario());
System.out.println("Opa....aqui está o usuario: "+ txtUsuarNome.getText());
}
} catch (Exception erro) {
JOptionPane.showMessageDialog(null,"Erro ao cosultar usuario"+ erro);
}
}
Nao mostra o usuario no campo txtUsuarNome do formulario. Estou ainda confuso!!
" Para usar os dados do usuário na view, basta obter o UsuarioDto retornado pelo método consultarUsuario :
UsuarioDto objUsuarioDTO = objUserDAO.consultarUsuario(funcId);
// aqui vc pega os atributos do usuario e seta nos campos da tela
```"
este foi o ultimo teste que fiz antes dessa resposta, ainda assim nao mostrou o nome do usuario no formulario.
voce está usando um if(usuario==null) retornando mensagem de erro, vou testar aqui.
O que estou falando é que retornar o ResultSet é muuito errado. Vc está criando um alto acoplamento que não deve acontecer de forma alguma. Para a tela do sistema, não importa se os dados estão vindos de um banco de dados, de um webservice, de um arquivo de texto. A tela só quer os dados referente ao usuário, ou seja, um objeto UsuarioDto preenchido.
É melhor retornar o usuário do método em vez do ResultSet.
Opa, beleza? A mudança que voce propôs testei, a linha
UsuarioDto usuario = usuarioDao.consultarUsuario(funcId);está com erro informando que UsuarioDto voi nao pode ser convertido para UsuarioDto. Mas consultar usuario e usuariodto sao void.
O método consultarUsuario não pode ser void. Ele deve retornar um UsuarioDto.
Ola amigo, beleza? Mas a propria modificacao que fez, colocou consultar() como void. O primeiro programa que postei, já retornava resulset. olhe ai…
Peguei seu código e fiz umas mudanças. Veja o que vc acha:
private void btnUsuarReadActionPerformed(java.awt.event.ActionEvent evt) {
consultar();
}
public void consultar() {
try {
// Obtém o ID do usuário informado na tela
int funcId = Integer.parseInt(txtUsuarId.getText());
// Cria o DAO para recuperar os dados do usuário
UsuarioDAO usuarioDao = new UsuarioDAO();
// Realiza a consulta do usuário pelo ID
UsuarioDto usuario = usuarioDao.consultarUsuario(funcId);
// Verifica se o usuário não foi encontrado
if (usuario == null) {
JOptionPane.showMessageDialog(null, "Usuário não encontrado para o ID " + funcId);
return;
}
// Preenche os campos do formulário para o usuário encontrado
txtUsuarNome.setText(usuario.getUsuario());
txtUsuarFone.setText(usuario.getFone());
txtUsuarLogin.setText(usuario.getLogin());
txtUsuarSenha.setText(usuario.getSenha());
cboUsuarPerfil.setSelectedItem(usuario.getPerfil());
} catch (Exception erro) {
JOptionPane.showMessageDialog(null, "Erro ao cosultar usuario: " + erro);
}
}
O erro está dando nesta sua linha:
UsuarioDto usuario = usuarioDao.consultarUsuario(funcId);
o metodo consultarUsuario na classe usuarioDAO, coloquei como:
public ResultSet consultarUsuario(int funcId)
retornando rs; que é uma variavel do tipo ResultSet rs;
O problema é esse. O método consultarUsuario não pode retornar ResultSet, mas um UsuarioDto.
Tem uma resposta minha que eu deixei um exemplo de como pegar os dados do ResultSet e converter para UsuarioDto.
" Tem uma resposta minha que eu deixei um exemplo de como pegar os dados do ResultSet e converter para UsuarioDto .">>>>Ok, mas as unicas dicas sao essas…
Lucas_CamaraHabitual
1
10d
Em vez de passar o UsuarioDto como parâmetro no método consultarUsuario . Faça o método retornar um UsuarioDto e receber o ID do funcionário como parâmetro. Assim:
public UsuarioDto consultarUsuario(int idFuncionario) {
}
Após fazer essa alteração, execute sua aplicação no modo debug e inspecione o valor retornado pelo método consultarUsuario da classe UsuarioDAO , e veja se os valores estão sendo retornados corretamente do banco de dados.
" Tem uma resposta minha que eu deixei um exemplo de como pegar os dados do ResultSet e converter para UsuarioDto .">>>>Ok, mas as unicas dicas sao essas…
" Essa agora está mais fácil. Com o UsuarioDto retornado do método consultarUsuario devidamente preenchido, agora basta vc chamar os métodos de cada campo setando o valor neles. Ex.:
txtUsuario.setText(usuarioDto.getUsuario());
Essa aqui:
O método recebe o ID e devolve um UsuarioDto.
public UsuarioDto consultarUsuario(int funcId) {
String sql = "SELECT * FROM tbUsuarios WHERE iduser = ?";
// chama modulo de conexao
conexao = new ModConexaoDAO().conector();
try {
pst = conexao.prepareStatement(sql);
pst.setInt(1, funcId);
rs = pst.executeQuery();
// verifica se o resultset possui dados
if (rs.next()) {
UsuarioDto objUsuarioDTO = new UsuarioDto();
objUsuarioDTO.setUsuario(rs.getString("NOME_DA_COLUNA"));
System.out.println(" o nome do usuario retornado no DAO é: " + objUsuarioDTO.getUsuario());
return objUsuarioDTO;
} else {
System.out.println("Nenhum resultado encontrado para o ID " + funcId);
return null;
}
} catch (Exception erro) {
JOptionPane.showMessageDialog(null, "Erro consultar usuario: " + erro);
return null;
} finally {
// feche aqui a conexão, o preparedStatement e o resultSet
}
}
Essa agora está mais fácil. Com o UsuarioDto retornado do método consultarUsuario devidamente preenchido, agora basta vc chamar os métodos de cada campo setando o valor neles. Ex.:
" Para usar os dados do usuário na view, basta obter o UsuarioDto retornado pelo método consultarUsuario :
UsuarioDto objUsuarioDTO = objUserDAO.consultarUsuario(funcId);
// aqui vc pega os atributos do usuario e seta nos campos da tela
Huffffffffffffffffffffff, nossa enfim funcionou. Obrigado pela paciência. essa linha receber o retorno do metodo objUsuarioDAO.consultarUsuario(funcId), como já mencionado. Porem quem está passando funcId para o metodo public UsuarioDto consultarUsuario (int idFunc)? É essa mesma linha >>objUsuarioDAO.consultarUsuario(funcId)<< que passa e aomesmo tempo recebe o funcId digitado pelo usuario??
1 curtida
Quem está passando o funcId como parâmetro é o método consultar da sua view.
Isso mesmo. Essa parte:
UsuarioDto usuario = objUsuarioDAO.consultarUsuario(funcId);
está enviando o funcId para o método consultarUsuario, e está recebendo um UsuarioDto como retorno.
Pense numa classe Calculadora, que tem um método soma. Esse método soma recebe 2 números e devolve a soma deles. O código ficaria assim:
public class Calculadora {
public int somar(int a, int b) {
return a + b;
}
}
e para chamar e recuperar o retorno:
public class TestaCalculadora {
public static void main(String args[]) {
Calculadora calculadora = new Calculadora();
// Invoca o método soma passando 2 números e recebe o valor calculadora
int valorSomado = calculadora.somar(10, 20);
System.out.println("O valor da soma é " + valorSomado);
}
}