Java com banco my sql

Aula 1- Criação do Banco de Dados

Vamos criar uma tabela no Mysql WorkBench:

1. Abra o Mysql WorkBench através do botão iniciar de seu desktop

2. Crie um banco de dados, escolhendo a opção “create schema”

3. Crie o seu banco de dados com o nome Orcamento.

4. Crie uma tabela com o create table.

5. Crie a tabela de calculo, conforme mostra a ilustração abaixo:

6. Defina o campo codigoCalculo como chave primária (PK) e auto incremento (AI)

7. Click em apply

3. Lembre-se de salvar o sql gerado em uma arquivo txt, isto o ajudara caso queira construí-lo sem usar o workbanch.

Aula 2 - Criação da Aplicação Java

Para que haja comunicação entre o banco de dados que criamos com a aplicação que faremos a seguir, é necessário carregar o driver da Linguagem Java (jdbc:Mysql) que será o responsável por fazer a ponte de comunicação com a fonte de dados. Para que a aula seja mais compreensível, vamos criar uma classe para fazer apenas a conexão com o banco de dados (classe “Conexao”) e uma outra classe que chamaremos de “Formulario” que fará a manipulação do banco (cadastramento, alteração, exclusão e consulta).

Conexão com o Banco de Dados

Faremos agora a conexão com o banco de dados por intermédio da fonte de dados criada anteriormente. Para que seja feita uma conexão é necessário carregar o driver que fará a comunicação com a fonte de dados e estabelecer uma conexão em si. Vamos ter a informação de que houve a conexão através de uma mensagem que será exibida na janela de prompt, indicando o sucesso da conexão ou não.

Veja a codificação abaixo necessária para fazer a conexão do banco de dados e em seguida as explicações sobre cada linha de comando:

Explicações das linhas de comando da classe Conexao:

Linha 1: import java.sql.* � faz a importação das classes do pacote SQL, necessárias para a criação da conexão com a ponte de dados JDBC-ODBC e das classes para a manipulação do banco de dados por meio dos comandos SQL.

Linha 3 - public class Conexao � criação da classe Conexão

Linha 5- static Connection con � cria uma conexão chamada con que será utilizada na linha 9

Linha 8 - public Conexao() � cria o método construtor da classe Conexão

Linha 12 - public void Conecta() � cria o método conecta que será responsável por realizar a conexão com o banco.

Linha 15 - Class.forName("org.gjt.mm.mysql.Driver") � carrega o driver que será usado pela aplicação Java para realizar a comunicação com o banco de dados. Observe que esta linha está inserida do bloco try-catch. Isto significa que se caso o driver não for localizado na máquina, deve ocorrer a exceção ClassNotFoundException que envia uma mensagem avisando o usuário do fato ocorrido - linha 16 - ("Driver JDBC-ODBC não encontrado"). Obs: O driver varia de acordo com o banco de dados a ser utilizado.

Linha 16 - con = DriverManager.getConnection ("jdbc:mysql://localhost/orcamento","root","123456") � estabelece uma conexão chamada com o nome da fonte de dados a ser usado na conexão, onde:

JDBC – é o driver da sun, responsável por fazer a conexão ao banco de dados.

MYSQL – é o driver referente à Mysql – varia de acordo com o banco que está sendo utilizado pela aplicação Java.

orcamento – é o nome do seu banco de dados, root é o usuário e a senha é 123456.(varia de acordo com a instalação do mysql).

Observe que esta linha também está inserida no bloco try-catch. Caso a conexão não possa ser realizada por qualquer motivo, ocorre a exceção SQLException que envia uma mensagem de alerta ao usuário na linha 21 - ("Problemas na conexão com o banco de dados").

Caso a conexão tenha sucesso é dado uma mensagem para o usuário informando (“Conexão realizada com sucesso")

Linha 28 - public void Fecha() � cria o método Fechar a conexão.

Linha 32- con.close()� fecha a conexão estabelecida na linha 9. Observe que esta linha também está inserida no bloco try-catch. Caso ocorra algum problema no encerramento da conexão, ocorre a exceção SQLException que envia uma mensagem de alerta ao usuário na linha 36 - ("Problemas no encerramento da conexão").

Observação: é necessário colocar estes dois componentes em seu programa para que possa funcionar tanto a conexão com banco de dados, quanto a classe data.

Aula 3 - Formulário de Cadastro

Criação do Formulário Principal onde o mesmo chamará os demais formulários.

Criação do Formulário de Cadastro e as manipulações com o banco de dados (Inclusão de registros, Exclusão de Registros, Alteração dos campos, Consulta através do campo chave e etc)

import java.sql.ResultSet; import java.text.DecimalFormat; import java.text.NumberFormat; import java.sql.SQLException; import java.sql.Statement; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.JOptionPane; public class Orcamento extends javax.swing.JFrame { int navega = 0; //variavel apenas para sabermos em qual botao foi clicado Conexao con_orcamento; double aliComissao = 0, aliMargem=0, aliImposto=0; /** Creates new form Orcamento */ public Orcamento() { initComponents(); Data mostraData = new Data(); mostraData.le_data(); txData.setText(""+mostraData.dia+"/"+mostraData.mes+"/"+mostraData.ano); }

//-----------------------------------Inicio do Gravar /Inserir------------------------------------------ private void btGravarActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btGravar)// mesmo nome da variavel (evt) ActionEvent txNumero.setEditable(false); { String sql = "insert into calculo (data,nome,horasProjeto,vlrHora,despesas," + "deslocamentoKm,vlrKm,vlrPedagio,comissao,margem,impostos) values ('"+ txData.getText()+"','"+ txCliente.getText()+"','"+ txHorasProjeto.getText()+"','"+ txVlrHora.getText()+"','"+ txDespesas.getText()+"','"+ txDeslocamento.getText()+"','"+ txVlrKm.getText()+"','"+ txPedagio.getText()+"','"+ txComissao.getText()+"','"+ txMargem.getText()+"','"+ txImpostos.getText()+"')"; conex.Conecta(); try { MeuState = Conexao.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); MeuState.executeUpdate(sql); JOptionPane.showMessageDialog(null,"Gravação realizada com sucesso !"); } catch (SQLException erro) { if (erro.getMessage().equals("General error")) { JOptionPane.showMessageDialog(null,"Curso já cadastrado"); } else { JOptionPane.showMessageDialog(null, "Dados inválidos"); } } } conex.fecha(); }

//-----------------------------------Fim do Gravar /Inserir------------------------------------------

//-----------------------------------Inicio do Excluir------------------------------------------ private void btExcluirActionPerformed(java.awt.event.ActionEvent evt) {

txNumero.setEditable(true); if (evt.getSource()==btExcluir) { try { String sql = "select *FROM calculo WHERE codigoCalculo ='"+txNumero.getText()+"'"; conex.Conecta(); MeuState = Conexao.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = MeuState.executeQuery(sql); String calculo=""; try { resultSet.next(); mostrar_dados(); calculo = "Deletar o Calculo "+resultSet.getString("codigoCalculo"); } catch (SQLException erro) { JOptionPane.showMessageDialog(null,"Calculo não Cadastrado"); return; } int c = JOptionPane.showConfirmDialog(null,calculo,"",JOptionPane.YES_NO_OPTION); if(c==JOptionPane.YES_OPTION) { sql="DELETE FROM calculo WHERE CodigoCalculo='"+txNumero.getText()+"'"; int r = MeuState.executeUpdate(sql); if(r==1) JOptionPane.showMessageDialog(null,"Exclusao realizada com sucesso!"); else JOptionPane.showMessageDialog(null, "Não foi possivel excluir o calculo!"); } } catch(SQLException erro) { JOptionPane.showMessageDialog(null,"Calculo não cadastrado!"); } } conex.fecha(); }

//-----------------------------------Fim do Excluir---------------------------------------------------

//----------------------------------------Inicio do Sair-------------------------------------------------- private void btSairActionPerformed(java.awt.event.ActionEvent evt) { dispose(); }

//------------------------------------------Fim do sair----------------------------------------------------

//----------------------------------------Inicio do Calcular--------------------------------------------- private void btCalcularActionPerformed(java.awt.event.ActionEvent evt) { double totalHoras, totalDeslocamento, despesas, pedagio, totalGeral; double comissao, imposto, margem; NumberFormat nf = new DecimalFormat("##,###.00"); totalHoras = Double.parseDouble(txHorasProjeto.getText())*Double.parseDouble(txVlrHora.getText()); totalDeslocamento = Double.parseDouble(txDeslocamento.getText())*Double.parseDouble(txVlrKm.getText()); despesas = Double.parseDouble(txDespesas.getText()); pedagio = Double.parseDouble(txPedagio.getText()); totalGeral = (despesas+totalHoras+totalDeslocamento+pedagio); comissao = Double.parseDouble(txComissao.getText()); margem = Double.parseDouble(txMargem.getText()); imposto = Double.parseDouble(txImpostos.getText()); totalGeral /= (1-((comissao+margem+imposto)/100)); aliComissao = totalGeral*(comissao/100); aliMargem = totalGeral*(margem/100); aliImposto = totalGeral*(imposto/100); lblComissao.setText("R$ "+nf.format(aliComissao)); lblMargem.setText("R$ "+nf.format(aliMargem)); lbImpostos.setText("R$ "+nf.format(aliImposto)); lbTotal.setText("R$ "+nf.format(totalGeral)); }

//-----------------------------------Fim do Calcular------------------------------------------

//-----------------------------------Inicio do Alterar------------------------------------------

private void btAlterarActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btAlterar) { String sql = "update calculo set data='"+txData.getText()+"', nome='"+txCliente.getText()+"'"+ ",horasProjeto='"+txHorasProjeto.getText()+"'" + ",vlrHora='"+txVlrHora.getText()+"'" + ",despesas='"+txDespesas.getText()+"'"+ ",deslocamentoKm='"+txDeslocamento.getText()+"'"+ ",vlrKm='"+txVlrKm.getText()+"'"+ ",vlrPedagio='"+txPedagio.getText()+"'"+ ",comissao='"+txComissao.getText()+"'"+ ",margem='"+txMargem.getText()+"'"+ ",impostos='"+txImpostos.getText()+"'"+ "where codigoCalculo='"+txNumero.getText()+"'"; conex.Conecta(); try {

MeuState = Conexao.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); int r = MeuState.executeUpdate(sql); if(r!=0) JOptionPane.showMessageDialog(null,"Alteração realizada com sucesso!"); else JOptionPane.showMessageDialog(null,"Problemas na alteração!"); } catch (SQLException erro) { JOptionPane.showMessageDialog(null,"Calculo não cadastrado!"); } } conex.fecha(); }

//-----------------------------------Fim do Alterar------------------------------------------

//-----------------------------------Inicio do Localizar------------------------------------------ private void btLocalizarActionPerformed(java.awt.event.ActionEvent evt) { txNumero.setEditable(true); if (evt.getSource()==btLocalizar) { try { String sql = "select *from calculo where codigoCalculo='"+txNumero.getText()+"'"; conex.Conecta(); MeuState = conex.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = MeuState.executeQuery(sql); resultSet.next(); mostrar_dados(); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } conex.fecha(); } }

//-----------------------------------Fim do Localizar------------------------------------------

//-----------------------------------Inicio do Proximo Registro------------------------------------------ private void btProximoActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btProximo)

{ try { resultSet.next(); mostrar_dados(); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } } }

//-----------------------------------Fim do Proximo Registro------------------------------------------

//-----------------------------------Inicio do Registro Anterior------------------------------------------ private void btAnteriorActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btAnterior) { try { resultSet.previous(); mostrar_dados(); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } } }

//-----------------------------------Fim do Registro Anterior------------------------------------------

//-----------------------------------Inicio do Primeiro Registro ------------------------------------------ private void btPrimeiroActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btPrimeiro) { try { String sql = "select *from calculo"; conex.Conecta(); MeuState = conex.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = MeuState.executeQuery(sql); resultSet.first(); mostrar_dados(); }

catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } } }

//-----------------------------------Fim do Primeiro Registro------------------------------------------

//-----------------------------------Inicio do Ultimo Registro ------------------------------------------ private void btUltimoActionPerformed(java.awt.event.ActionEvent evt) { if (evt.getSource()==btUltimo) { try { String sql = "select *from calculo"; conex.Conecta(); MeuState = conex.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = MeuState.executeQuery(sql); resultSet.last(); mostrar_dados(); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } } }

//-----------------------------------Fim do Ultimo Registro------------------------------------------

//-----------------------------------Inicio do método Principal------------------------------------------ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new Orcamento().setVisible(true); } }); }

//-----------------------------------Fim do método Principal------------------------------------------

//-----------------------------------Declaração Variáveis------------------------------------------ Conexao conex = new Conexao(); static Statement MeuState;

ResultSet resultSet; // Variables declaration - do not modify private javax.swing.JButton btAlterar; private javax.swing.JButton btAnterior; private javax.swing.JButton btCalcular; private javax.swing.JButton btExcluir; private javax.swing.JButton btGravar; private javax.swing.JButton btLocalizar; private javax.swing.JButton btPrimeiro; private javax.swing.JButton btProximo; private javax.swing.JButton btSair; private javax.swing.JButton btUltimo; private javax.swing.JPanel jPanel1; private javax.swing.JPanel jPanel2; private javax.swing.JSeparator jSeparator1; private javax.swing.JLabel lbCabecalho; private javax.swing.JLabel lbCliente; private javax.swing.JLabel lbData; private javax.swing.JLabel lbHorasProjeto; private javax.swing.JLabel lbHorasProjeto1; private javax.swing.JLabel lbHorasProjeto2; private javax.swing.JLabel lbHorasProjeto3; private javax.swing.JLabel lbHorasProjeto4; private javax.swing.JLabel lbImpostos; private javax.swing.JLabel lbNumero; private javax.swing.JLabel lbTotal; private javax.swing.JLabel lbVlrHora; private javax.swing.JLabel lbVlrHora1; private javax.swing.JLabel lbVlrHora2; private javax.swing.JLabel lbVlrHora3; private javax.swing.JLabel lblComissao; private javax.swing.JLabel lblMargem; private javax.swing.JTextField txCliente; private javax.swing.JTextField txComissao; private javax.swing.JTextField txData; private javax.swing.JTextField txDeslocamento; private javax.swing.JTextField txDespesas; private javax.swing.JTextField txHorasProjeto; private javax.swing.JTextField txImpostos; private javax.swing.JTextField txMargem; private javax.swing.JTextField txNumero; private javax.swing.JTextField txPedagio; private javax.swing.JTextField txVlrHora; private javax.swing.JTextField txVlrKm; // End of variables declaration public void mostrar_dados() { try

{ txNumero.setText(resultSet.getString("codigoCalculo")); txData.setText(resultSet.getString("data")); txCliente.setText(resultSet.getString("nome")); txHorasProjeto.setText(resultSet.getString("horasProjeto")); txVlrHora.setText(resultSet.getString("vlrHora")); txDespesas.setText(resultSet.getString("despesas")); txDeslocamento.setText(resultSet.getString("deslocamentoKM")); txVlrKm.setText(resultSet.getString("vlrKm")); txPedagio.setText(resultSet.getString("vlrPedagio")); txComissao.setText(resultSet.getString("comissao")); txMargem.setText(resultSet.getString("margem")); txImpostos.setText(resultSet.getString("impostos")); } catch(SQLException erro) { } } } txData.setText(""+mostraData.dia+"/"+mostraData.mes+"/"+mostraData.ano); }

No código acima, podemos observar a criação de um objeto MeuState : static Statement MeuState;. A interface Statement permite executar um comando SQL que será usado no programa.

Após temos a criação de um objeto resultSet do tipo ResultSet, este objeto armazena o resultado da operação SQL em memória, assim como uma variável qualquer. Por este motivo, a cada operação realizada fisicamente no banco de dados pelos comandos SQL, o objeto resultSet fica com o conteúdo diferente da tabela do banco de dados. Então, todas as vezes que o banco de dados é alterado, o objeto resultSet precisa ser recarregado com todos os registros da tabela. O método Conecta da classe Conexao é responsável por realizar a conexão com o banco de dados e inicializar o objeto resultSet com todos os registros da tabela pelo comando “SELECT * FROM TBCALCULO”.

//-----------------------------------Classe mostra data------------------------------------------

import java.util.Date; import java.text.SimpleDateFormat; public class Data {

public String mes, dia, ano, dia_semana, hora; SimpleDateFormat horaformatada = new SimpleDateFormat("HH:mm:ss"); public void le_hora() { Date horaAtual = new Date(); hora = horaformatada.format(horaAtual); } public void le_data() { Date data = new Date(); dia = ""+data.getDate(); ano = ""+(1900 + data.getYear()); switch(data.getDay()) { case 0: dia_semana = "Domingo";break; case 1: dia_semana = "Segunda";break; case 2: dia_semana = "Terça";break; case 3: dia_semana = "Quarta";break; case 4: dia_semana = "Quinta";break; case 5: dia_semana = "Sexta";break; case 6: dia_semana = "Sábado";break; } switch(data.getMonth()) { case 0: mes = "Janeiro";break; case 1: mes = "Fevereiro";break; case 2: mes = "Março";break; case 3: mes = "Abril";break; case 4: mes = "Maio";break; case 5: mes = "Junho";break; case 6: mes = "Julho";break; case 7: mes = "Agosto";break; case 8: mes = "Setembro";break; case 9: mes = "Outubro";break; case 10: mes = "Novembro";break; case 11: mes = "Dezembro";break; } } }

A classe data é utilizada para coletar e tratar a data do sistema, porem para sua utilização é necessário a instalação de um componente timer.

Aula 4 - Rotina de Inserção de Registros

Vamos estudar a codificação da rotina para inserir novos registros na nossa tabela de alunos (CALCULO) criada no MySQL:

//-----------------------------------Inicio do Gravar /Inserir------------------------------------------

private void btGravarActionPerformed(java.awt.event.ActionEvent evt) {

if (evt.getSource()==btGravar)// mesmo nome da variavel (evt) ActionEvent

txNumero.setEditable(false);

{

String sql = "insert into calculo (data,nome,horasProjeto,vlrHora,despesas," +

"deslocamentoKm,vlrKm,vlrPedagio,comissao,margem,impostos) values ('"+

txData.getText()+"','"+

txCliente.getText()+"','"+

txHorasProjeto.getText()+"','"+

txVlrHora.getText()+"','"+

txDespesas.getText()+"','"+

txDeslocamento.getText()+"','"+

txVlrKm.getText()+"','"+

txPedagio.getText()+"','"+

txComissao.getText()+"','"+

txMargem.getText()+"','"+

txImpostos.getText()+"')";

conex.Conecta();

try

{

MeuState = Conexao.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,

ResultSet.CONCUR_READ_ONLY);

MeuState.executeUpdate(sql);

JOptionPane.showMessageDialog(null,"Gravação realizada com sucesso !");

}

catch (SQLException erro)

{

if (erro.getMessage().equals("General error"))

{

JOptionPane.showMessageDialog(null,"Curso já cadastrado");

}

else

{

JOptionPane.showMessageDialog(null, "Dados inválidos");

}

}

}

conex.fecha();

}

//-----------------------------------Fim do Gravar /Inserir------------------------------------------

if (evt.getSource()==btInserir) { � Se o usuário pressionar o botão Inserir, ocorrem os seguintes procedimentos descritos nas linhas abaixo.

Contém a declaração de uma string chamada sql usada para armazenar o

conteúdo do comando que será usado na inserção de um registro. Para inserir

um registro, usamos o seguinte padrão SQL: INSERT INTO nome da tabela

(nomes dos campos) Values (conteúdo dos campos). Como sabemos pelos

conceitos do SQL, INSERT INTO informa que um registro será inserido. A

seguir será informado o nome da tabela, neste caso, TBALUNOS (nome da

tabela que criei no Mysql). Ao inserir um registro, é necessário especificar em

quais campos do registro serão inseridos os valores. Neste caso, serão

inseridos valores em todos os campos, como pode ser observado entre

(data,nome,horasProjeto,vlrHora,despesas,""deslocamentoKm,vlrKm,vlrPedagio,comissao,mar

gem,impostos). Feito isto é preciso definir os conteúdos dos valores. Isto é feito a

partir da palavra Values, como pode ser observado no: Values ('"+

txData.getText()+"','"+

txCliente.getText()+"','"+

txHorasProjeto.getText()+"','"+

txVlrHora.getText()+"','"+

txDespesas.getText()+"','"+

txDeslocamento.getText()+"','"+

txVlrKm.getText()+"','"+

txPedagio.getText()+"','"+

txComissao.getText()+"','"+

txMargem.getText()+"','"+

txImpostos.getText()+"')";

O conteúdo a ser inserido deve ser colocado na mesma ordem dos nomes dos

campos.

conex.Conecta(); � Esta linha chama a conexão com o banco de dados, através do método Conecta() criado na classe Conexão

MeuState = Conexao.con.createStatement(); �� cria um statement, isto é, um objeto chamado MeuState que possibilita a utilização de um comando SQL na conexão realizada com o banco de dados chamada “con”. Pode-se dizer que a interface Statement permite executar um comando SQL que será usado no programa.

ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY ��

permite você fazer as alterações no banco, sem esta linha seu programa

exibira um erro de thead.

MeuState.executeUpdate(sql); �� o método executeUpdate é usado para executar comandos SQL de ação na linguagem Java.

Se a conexão for estabelecida com o banco de dados sem nenhum problema, é dado a seguinte mensagem:"Gravação realizada com sucesso !"

Tratamento de exceções �� if (erro.getMessage().equals("General error")) – Valida se o campo matrícula (que é nossa chave primária) está sendo duplicado. Se estiver, é dado a seguinte mensagem: "Aluno já cadastrado" . Se o usuário cadastrou a data errada, dar a mensagem: "Data inválida". Tratei apenas estas exceções, mas você pode acrescentar mais funcionalidades para tratamento de erros, deixando seu sistema mais conciso.

conex.Fecha();� Fecha a conexão com o banco de dados.

Aula 5 - Rotina de Alteração de Registros

Vamos estudar a codificação da rotina para alterar nossos registros gravados na tabela de alunos (CALCULO) criada no MySQL:

//-----------------------------------Inicio do Alterar------------------------------------------

private void btAlterarActionPerformed(java.awt.event.ActionEvent evt) {

if (evt.getSource()==btAlterar)

{

String sql = "update calculo set data='"+txData.getText()+"',

nome='"+txCliente.getText()+"'"+

",horasProjeto='"+txHorasProjeto.getText()+"'" +

",vlrHora='"+txVlrHora.getText()+"'" +

",despesas='"+txDespesas.getText()+"'"+

",deslocamentoKm='"+txDeslocamento.getText()+"'"+

",vlrKm='"+txVlrKm.getText()+"'"+

",vlrPedagio='"+txPedagio.getText()+"'"+

",comissao='"+txComissao.getText()+"'"+

",margem='"+txMargem.getText()+"'"+

",impostos='"+txImpostos.getText()+"'"+

"where codigoCalculo='"+txNumero.getText()+"'";

conex.Conecta();

try

{



int r = MeuState.executeUpdate(sql);

if(r!=0)

JOptionPane.showMessageDialog(null,"Alteração realizada com sucesso!");

else

JOptionPane.showMessageDialog(null,"Problemas na alteração!");

}


{

JOptionPane.showMessageDialog(null,"Calculo não cadastrado!");

}

}

conex.fecha();

}

//-----------------------------------Fim do Alterar------------------------------------------

if (e.getSource()==btAtualizar)� Se o usuário pressionar o botão Atualizar, ocorrem os seguintes procedimentos descritos nas linhas abaixo.

Contém a declaração do comando SQL que faz a alteração, através da string chamada sql usada para armazenar o conteúdo do comando que será usado na atualização do registro. Para alterar um registro, usamos o seguinte padrão SQL: UPDATE nome da tabela SET nome dos campos = conteúdo dos campos WHERE nome do campo = condição.

Como sabemos pelos conceitos do SQL, a palavra UPDATE informa que um

registro será atualizado, no caso, a tabela TBCalculo. A seguir, é colocado a

palavra SET que definirá o nome dos campos e os conteúdos correspondentes

a serem gravados. Ao alterar um registro, é necessário especificar em quais

campos do registro os valores serão atualizados. Observe que todos os

campos ('"+txData.getText()+"', nome='"+txCliente.getText()+"'"+

",horasProjeto='"+txHorasProjeto.getText()+"'" +

",vlrHora='"+txVlrHora.getText()+"'" +

",despesas='"+txDespesas.getText()+"'"+

",deslocamentoKm='"+txDeslocamento.getText()+"'"+

",vlrKm='"+txVlrKm.getText()+"'"+

",vlrPedagio='"+txPedagio.getText()+"'"+

",comissao='"+txComissao.getText()+"'"+

",margem='"+txMargem.getText()+"'"+

",impostos='"+txImpostos.getText()+"'"+

"where codigoCalculo='"+txNumero.getText()+"'";

) são usados e seu conteúdo provém das caixas de texto do formulário. A palavra WHERE define a condição para que o registro seja atualizado e esta condição será sempre verificada a partir da matrícula do aluno. Por exemplo: atualize o registro em que a matrícula do aluno seja “42006” (WHERE codigoCalculo = “42006”). Isto significa que antes de atualizar o registro, o comando SQL varre os registros a partir da matrícula 42006 e ao encontrar realiza a alteração.

conex.Conecta(); � Esta linha chama a conexão com o banco de dados, através do método Conecta() criado na classe Conexão.


int r = MeuState.executeUpdate(sql); �� execução do comando para atualização do registro. Da mesma forma que na inserção, para alterar um registro também é usado o método executeUpdate.

if (r==1) �� Nesta linha foi usada uma variável “r” para verificar o sucesso ou não do comando de atualização. Se o resultado da ação retornar a 1, ou seja, se r receber 1, significa que o comando SQL foi executado com sucesso, caso contrário, significa que não obteve sucesso na alteração dos dados, pois pode acontecer do registro não existir na tabela

Aula 6 - Rotina de Exclusão de Registros

Vamos estudar a codificação da rotina para excluir os registros gravados na nossa tabela de alunos (TBORCAMENTO) criada no MySQL:

//-----------------------------------Inicio do Excluir------------------------------------------

private void btExcluirActionPerformed(java.awt.event.ActionEvent evt)

{

txNumero.setEditable(true);

if (evt.getSource()==btExcluir)

{

try

{

String sql = "select *FROM calculo WHERE codigoCalculo ='"+txNumero.getText()+"'";

conex.Conecta();



resultSet = MeuState.executeQuery(sql);

String calculo="";

try

{

resultSet.next();

mostrar_dados();

calculo = "Deletar o Calculo "+resultSet.getString("codigoCalculo");

}


{

JOptionPane.showMessageDialog(null,"Calculo não Cadastrado");

return;

}

int c = JOptionPane.showConfirmDialog(null,calculo,"",JOptionPane.YES_NO_OPTION);

if(c==JOptionPane.YES_OPTION)

{

sql="DELETE FROM calculo WHERE CodigoCalculo='"+txNumero.getText()+"'";

int r = MeuState.executeUpdate(sql);

if(r==1)

JOptionPane.showMessageDialog(null,"Exclusao realizada com sucesso!");

else

JOptionPane.showMessageDialog(null, "Não foi possivel excluir o calculo!");

}

}

catch(SQLException erro)

{

JOptionPane.showMessageDialog(null,"Calculo não cadastrado!");

}

}

conex.fecha();

}

//-----------------------------------Fim do Excluir---------------------------------------------------

if (e.getSource()==btExcluir)� Se o usuário pressionar o botão Excluir, ocorrem os seguintes procedimentos descritos nas linhas abaixo.

Contém a declaração do comando SQL que faz uma procura, através da string chamada sql , para verificar se o aluno a ser excluído realmente existe. O conteúdo presente na caixa de texto referente ao codigo (txNumero) será usado no comando SQL para localizar o aluno a ser excluído.

Estão no bloco try-catch. Se o aluno não for encontrado, será dado uma mensagem de Aluno não cadastrado.



resultSet = MeuState.executeQuery(sql); � O método executeQuery faz uma consulta à procura do(s) campo(s) solicitado(s) e o resultado desta ação é armazenado no objeto resultSet. O comando SQL inserido no método executeQuery significa: Selecione (SELECT) todos os campos da tabela calculo (FROM TBCalculo) em que (WHERE) o numero do aluno seja aquela digitada na caixa de texto da matrícula (txNumero.getText()). O resultado do comando SQL será armazenado no objeto resultSet com o formato de uma tabela contendo linhas e colunas (registros) relativos à tabela em que a consulta é realizada, neste caso, da tabela TBCalculo. Se o numero não for encontrado, será enviado uma mensagem - "Calculo não cadastrado!" e a ação de exclusão será cancelada.

Linha 9 - String nom= ""; � Cria a variável nom do tipo String e vazia. Esta variável guarda o numero do orcamento que será excluído e será usada na mensagem de confirmação, perguntando ao usuário se deseja excluir o aluno selecionado para a exclusão.

resultSet.next(); � O objeto resultSet avança o próximo registro.

calculo ="Deletar o orcamento " + resultSet.getString("codigoCalculo"); � O método getString é responsável por recuperar um dado do tipo String armazenado na tabela. Neste caso, o método captura o numero do orcamento do registro a ser excluído. A variável calculo recebe a frase “Deletar o calculo” + numero do calculo capturado pelo método getString.

int n= JOptionPane.showConfirmDialog(null,nom,"", JOptionPane.YES_NO_OPTION); �� Mostra uma mensagem de confirmação na tela como mostra a figura abaixo:

Lembrando que a variável calculo guarda o conteúdo: “Deletar o calculo” + o numero do calculo capturado pelo método getString e a mensagem construída pelo JoptionPane cria dois botões: Yes e No.

if (n==JOptionPane.YES_OPTION) { sql="DELETE FROM TBOrcamento Where codigoCalculo='"+txNumero.getText()+"'"; �� é feito a verificação de qual botão foi selecionado na mensagem. Se for o botão “Yes”, será criado o comando SQL para excluir o calculo, no seguinte formato: DELETE FROM nome da tabela WHERE condição. Antes de excluir é necessário localizá-lo, o que é feito pela cláusula WHERE seguida da condição. Neste caso, é selecionado o registro cuja numero do calculo seja igual ao numero digitado no txNumero, capturado através do método getText.

int r = MeuState.executeUpdate(sql); �� execução do comando para exclusão do registro. Da mesma forma que na inserção e na atualização, para excluir um registro também é usado o método executeUpdate que permite executar comandos de ação.

if (r==1) �� Nesta linha foi usada uma variável “r” para verificar o sucesso ou não do comando de exclusão. Se o resultado da ação retornar a 1, ou seja, se r receber 1, significa que o comando SQL foi executado com sucesso, caso contrário, significa que não obteve sucesso na exclusão dos dados.

JOptionPane.showMessageDialog(null,"Exclusão realizada com sucesso!"); � Será apresentada na tela uma mensagem informando que a exclusão foi realizada com sucesso..

JOptionPane.showMessageDialog(null,"Não foi possível excluir o aluno!"); �� Será apresentada na tela uma mensagem informando que não foi possível excluir o aluno!

conex.Fecha();� Fecha a conexão com o banco de dados.

Aula 7- Rotina de Localização de Registros

Vamos estudar a codificação da rotina para localizar um registro gravado na nossa tabela de alunos (TBOrcamento) criada no MySql, através do campo chave (codigoCalculo):

//-----------------------------------Inicio do Localizar------------------------------------------

private void btLocalizarActionPerformed(java.awt.event.ActionEvent evt) { txNumero.setEditable(true); if (evt.getSource()==btLocalizar) { try { String sql = "select *from calculo where codigoCalculo='"+txNumero.getText()+"'"; conex.Conecta();

MeuState = conex.con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); resultSet = MeuState.executeQuery(sql); resultSet.next(); mostrar_dados(); } catch(SQLException erro) { JOptionPane.showMessageDialog(null, "Calculo não Cadastrado"); return; } conex.fecha(); } }

//-----------------------------------Fim do Localizar------------------------------------------

if (e.getSource()==btLocalizar) )� Se o usuário pressionar o botão Localizar, ocorrem os seguintes procedimentos descritos nas linhas abaixo:

String sql= "SELECT * FROM TBCalculo Where codigoCalculo=' "+txNumero.getText()+" ' "; � Nesta linha é definido o comando SQL responsável pela localização do registro. SELECT (selecione) FROM TBCalculo (da tabela calculo) WHERE (onde) codigoCalculo = txNumero.getText (o codigo seja igual ao valor digitado no campo txNumero, capturado pelo método getText). Observe que esta linha de comando está inserida no bloco try-catch. Se o aluno não for encontrado, será mostrada uma mensagem na tela informando que o aluno não foi encontrado.


MeuState = Conex.con.createStatement(); �� cria um statement, isto é, um objeto chamado MeuState que possibilita a utilização de um comando SQL na conexão realizada com o banco de dados chamada “con”. Pode-se dizer que a interface Statement permite executar um comando SQL que será usado no programa.

resultSet = MeuState.executeQuery(sql); �� o método executeUpdate é usado para executar comandos SQL de ação na linguagem Java.

resultSet.next();� O objeto resultSet avança o próximo registro.

ATIVIDADE

1- Crie uma tabela no Mysql WorkBench, conforme mostra a figura abaixo:

2- Crie uma classe para fazer a conexão com o banco de dado.

3- Crie uma classe contendo o formulário de cadastro de professores, incluindo nele as rotinas de Inclusão de registros, Alteração, Exclusão, Localização e um botão para limpar os campos.

Java com banco my sql

Documents

Transcript of Java com banco my sql