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();
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---------------------------------------------------
//----------------------------------------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
{

if(r!=0)
JOptionPane.showMessageDialog(null,"Alteração realizada com sucesso!");
else
JOptionPane.showMessageDialog(null,"Problemas na alteração!");
}
{
}
}
conex.fecha();
}
//-----------------------------------Fim do Alterar------------------------------------------
//-----------------------------------Inicio do Localizar------------------------------------------
private void btLocalizarActionPerformed(java.awt.event.ActionEvent evt) {
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.next();
mostrar_dados();
}
{
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();
}
{
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();
}
{
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();
resultSet.first();
mostrar_dados();
}

{
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();
resultSet.last();
mostrar_dados();
}
{
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 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 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"));
}
{
}
}
}
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 ('"+
conex.Conecta();
try
{
MeuState.executeUpdate(sql);
JOptionPane.showMessageDialog(null,"Gravação realizada com sucesso !");
}
{
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 ('"+
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()+"'"+

conex.Conecta();
try
{
if(r!=0)
JOptionPane.showMessageDialog(null,"Alteração realizada com sucesso!");
else
JOptionPane.showMessageDialog(null,"Problemas na alteração!");
}
{
}
}
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()+"'"+

) 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.
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)
{
if (evt.getSource()==btExcluir)
{
try

{
String sql = "select *FROM calculo WHERE codigoCalculo ='"+txNumero.getText()+"'";
conex.Conecta();
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()+"'";
if(r==1)
JOptionPane.showMessageDialog(null,"Exclusao realizada com sucesso!");
else
JOptionPane.showMessageDialog(null, "Não foi possivel excluir o calculo!");
}
}
{
}
}
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) {
if (evt.getSource()==btLocalizar)
{
try
{
String sql = "select *from calculo where codigoCalculo='"+txNumero.getText()+"'";
conex.Conecta();

resultSet.next();
mostrar_dados();
}
{
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 é,
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

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Java com banco my sql

Semelhante a Java com banco my sql (20)

Java com banco my sql