DISCIPLINA: LINGUAGEM E TECNICAS DE PROGRAMAÇÃO I – JAVA SE

PROFESSOR: JUNIO FIGUEIREDO

ALUNO(A): ____________________________________

Exercício de Java

Utilizando o Eclipse:

JDBC – Java DataBase Conection

1. Java Database Connectivity ou JDBC é um conjunto de classes e interfaces1 (API) escritas

em Java que fazem o envio de instruções SQL para qualquer banco de dados relacional;

JAVA

java.sql

MySQL
Connector/J
Driver JDBC

DB

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 2. Agora vamos configurar o driver de comunicação do Mysql com Java.

Configuração do driver
JDBC do MySQL

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
Acesse o endereço http://dev.mysql.com/downloads/connector/j/

Obs. A versão atual do MySQL é: 5.1.44

Clique em

Na próxima pagina clique em :

Em alguns instantes é realizado o download.

Fica o seu critério, o local, para descompactar o conector.

Vamos configurar o Eclipse para utilizar o MySQL

Abra o eclipse

Crie um Projeto com o seguinte nome JDBCMySQL.

Clique com no projeto com o botão direito, escolha properties

Selecione do lado direito da Janela a opção Java Build Path e a aba Libaries

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
Localizando o arquivo do MySQL

Clique com o botão direito na opção Add External JARs.

Clique em Open e localize o arquivo

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
Verifique se o arquivo aparece em Libaries, conforme figura abaixo:

Clique no botão OK

Verifique o projeto no eclipse.

Finalizamos a configuração do driver do MySQL.

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 3. Abra o MySQL Workbench e crie um Banco de Dados chamado livraria
4. Vamos criar uma tabela chamada de editora

Clique no botão Apply

Ou

O comando de criar tabela

CREATE TABLE ‘livraria’.’editora’ (

‘idEditora’ INT NOT NULL AUTO_INCREMENT,
‘nome’ VARCHAR(100) NULL,
‘email’ VARCHAR(100) NULL,
PRIMARY KEY (‘idEditora’));

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 5. No eclipse, crie um pacote chamado de jdbc.util, em seguida crie uma classe chamada de
ConnectionFactory.

 DriverManager,criar uma instância da conexão como banco de dados.

 O método responsável pela criação dessa instância é :
getConnection(Stringurl,Stringusuario,Stringsenha);

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import javax.swing.JOptionPane;

public class ConnectionFactory {

public static Connection createConnection() {

String stringDeConexao =
"jdbc:mysql://localhost:3306/livraria";
String usuario = "root";
String senha = "";//coloque a senha do seu BD

Connection conexao = null;

try {
conexao =
DriverManager.getConnection(stringDeConexao, usuario,
senha);
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "Não Foi
Possivel Realizar Conexão com o BD ");
}
return conexao;

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 6. Vamos testar a conexão

public static void main(String[] args) {

new ConnectionFactory().createConnection();

JOptionPane.showMessageDialog(null, "Conexao realizada!!!");

7. Crie uma pacote chamado de jdbc.modelo com uma classe chamada de Editora.

public class Editora {

private Long idEditora;

private String nome;
private String email;

// Gerar Getters e Setters

8. Vamos serializar

public class Editora implements Serializable {

/**
*
*/
private static final long serialVersionUID = 1L;

private Long idEditora;

private String nome;
private String email;

}
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 9. Vamos ampliar o nosso conhecimento, trabalhando com MVC
10. Crie um pacote chamado jdbc.dao e uma classe chamada de EditoraSalvar.

 A criação do Statement é necessária para que possamos executar os comandos SQL

diretamente no banco de dados.
 Os métodos do Statement utilizados para executar os comandos SQL são:
execute() // Método retorna um booleano
executeUpdate() // Retorna um inteiro. (número de linhas).
executeQuery().//Retorna junto com o ResultSet o resultado da
consulta.

11. Pode copiar

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import jdbc.modelo.Editora;
import jdbc.util.ConnectionFactory;
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 public class EditoraSalvar {
private Connection conexao;
PreparedStatement stmt;

public EditoraSalvar() {
this.conexao =
ConnectionFactory.createConnection();
}

public void salvar(Editora editora){

try {
String sql = "Insert into
editora(nome, email)"
+ " values(?,?) ";

stmt = conexao.prepareStatement(sql);
stmt.setString(1,editora.getNome());
stmt.setString(2,editora.getEmail());
stmt.execute();

stmt.close();//esse método retorna um

boolean
conexao.close();

} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 }

12. Crie um pacote chamado jdbc.visao e uma classe chamada de TestaEditora.

import jdbc.dao.EditoraSalvar;
import jdbc.modelo.Editora;

public class TestaEditora {

public static void main(String[] args) {

Editora editora = new Editora();

editora.setNome(JOptionPane.showInputDialog("Infor
me o Nome da Editora "));

editora.setEmail(JOptionPane.showInputDialog("Info
rme o Email da Editora "));

EditoraSalvar editorasalvar = new

EditoraSalvar();
editorasalvar.salvar(editora);

JOptionPane.showMessageDialog(null,
"Operação Realizada com Sucesso!!");

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 }
}

13. Crie dentro do pacote jdbc.Dao uma classe chamada de EditoraListar.

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import jdbc.modelo.Editora;
import jdbc.util.ConnectionFactory;

public class EditoraListar {

private Connection conexao;

PreparedStatement stmt;
ResultSet resultado;

public EditoraListar() {
this.conexao =
ConnectionFactory.createConnection();
}

public List<Editora> listar() {

List<Editora> lista = new
ArrayList<Editora>();
try {
stmt = conexao.prepareStatement("Select *
from Editora");

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 resultado = stmt.executeQuery();

while (resultado.next()) {
Editora editora = new Editora();

editora.setIdEditora(resultado.getLong(1));

editora.setNome(resultado.getString(2));

editora.setEmail(resultado.getString(3));
lista.add(editora);
}

stmt.close();
resultado.close();
conexao.close();

} catch (SQLException e) {
e.printStackTrace();
}
return lista;

}
}

14. No Pacote jdbc.visao crie uma classe chamada de TestaListarEditora

import java.util.List;

import jdbc.dao.EditoraListar;
import jdbc.modelo.Editora;

public class TestaListaEditora {

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 public static void main(String[] args) {

EditoraListar editoralistar = new

EditoraListar();
List<Editora> lista = editoralistar.listar();

for (Editora e : lista) {

System.out.println("Editora :" +
e.getIdEditora() + " - " + e.getNome() + " - " +
e.getEmail());
}

15. Crie dentro do pacote jdbc.Dao uma classe chamada de EditoraAlterar

package jdbc.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import jdbc.modelo.Editora;
import jdbc.util.ConnectionFactory;

public class EditoraAlterar {

private Connection conexao;

PreparedStatement stmt;

public EditoraAlterar() {
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 this.conexao =
ConnectionFactory.createConnection();
}

public void alterar(Editora editora){

try {
String sql = "Update editora set nome =
?, email = ? where idEditora = ?";

stmt = conexao.prepareStatement(sql);
stmt.setString(1,editora.getNome());
stmt.setString(2,editora.getEmail());
stmt.setLong(3,editora.getIdEditora());
stmt.execute();

stmt.close();//esse método retorna um

boolean
conexao.close();

} catch (SQLException e) {
e.printStackTrace();
}

}
.

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 16. No Pacote jdbc.visao crie uma classe chamada de TestaAlterarEditora

package jdbc.visao;

import java.util.List;

import jdbc.dao.EditoraAlterar;
import jdbc.dao.EditoraListar;
import jdbc.modelo.Editora;

public class TestaAlterarcao {

public static void main(String[] args) {

Editora editora = new Editora();
//Alterando o Codigo 2
editora.setIdEditora(2l);
editora.setNome("Saraiva");
editora.setEmail("saraiva@saraiva.com");

//Chamada do método para alterar

EditoraAlterar alterar = new
EditoraAlterar();
alterar.alterar(editora);
System.out.println("Operação Realizada Com
Sucesso!!");

// Listando a Editora
EditoraListar editoralistar = new
EditoraListar();
List<Editora> lista = editoralistar.listar();

for (Editora e : lista) {

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 System.out.println("Editora :" +
e.getIdEditora() + " - " + e.getNome() + " - " +
e.getEmail());
}

16.Vamos testar o alterar, Crie dentro do pacote jdbc.Visao uma classe chamada de
TestaAlterarcao

package jdbc.visao;

import java.util.List;

import jdbc.dao.EditoraAlterar;
import jdbc.dao.EditoraListar;
import jdbc.modelo.Editora;

public class TestaAlterarcao {

public static void main(String[] args) {

Editora editora = new Editora();
//Alterando o Codigo 2
editora.setIdEditora(2l);
editora.setNome("Saraiva");
editora.setEmail("saraiva@saraiva.com");

//Chamada do método para alterar

EditoraAlterar alterar = new
EditoraAlterar();
alterar.alterar(editora);

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 System.out.println("Operação Realizada Com
Sucesso!!");

// Listando a Editora
EditoraListar editoralistar = new
EditoraListar();
List<Editora> lista = editoralistar.listar();

for (Editora e : lista) {

System.out.println("Editora :" +
e.getIdEditora() + " - " + e.getNome() + " - " +
e.getEmail());
}

16.Para Finalizar o CRUD, vamos criar dentro do pacote jdbc.DAO uma classe chamada
de EditoraExcluir.

package jdbc.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import jdbc.modelo.Editora;
import jdbc.util.ConnectionFactory;

public class EditoraExcluir {

private Connection conexao;
PreparedStatement stmt;
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 public EditoraExcluir() {
this.conexao =
ConnectionFactory.createConnection();
}

public void excluir(int id){

try {
String sql = "Delete from editora where
idEditora = ? ";

stmt = conexao.prepareStatement(sql);
stmt.setLong(1,id);
stmt.execute();

stmt.close();//esse método retorna um

boolean
conexao.close();

} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 17.Vamos testar o excluir, Crie dentro do pacote jdbc.Visao uma classe chamada de
TestaExcluisao.

package jdbc.visao;

import java.util.List;

import jdbc.dao.EditoraAlterar;
import jdbc.dao.EditoraExcluir;
import jdbc.dao.EditoraListar;
import jdbc.modelo.Editora;

public class TestaExclusao {

public static void main(String[] args) {

//Chamada do método para excluir

EditoraExcluir excluir = new
EditoraExcluir();
//Já Passando o código da editora para
exclusao
excluir.excluir(2);
System.out.println("Operação Realizada Com
Sucesso!!");

// Listando a Editora
EditoraListar editoralistar = new
EditoraListar();
List<Editora> lista = editoralistar.listar();

for (Editora e : lista) {

System.out.println("Editora :" +
e.getIdEditora() + " - " + e.getNome() + " - " +
e.getEmail());
1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente
 }

Exercício: JDBC e MySQL

Crie uma Banco de Dados chamado de Tarefa, com a seguinte tabela produto

ÍNDICE
ATRIBUTO TIPO NULO DESCRIÇÃO DOMÍNIO
PRI EST CAN

codigo int não Código do produto x

nome varchar(40) não Nome do produto x

descrição varchar(45) não Descrição do produto

venda DECIMAL(6,2) não Preço de venda

custo DECIMAL(6,2) não Preço de custo

quantest int não Quantidade em estoque

Você deverá criar o programa para Alterar e Excluir

Que a Força Esteja com Você

1 – Interfaces - define ações que devem ser obrigatoriamente executadas, mas que cada classe pode
executar de forma diferente