Your SlideShare is downloading. ×
Java 16 Jdbc
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Java 16 Jdbc

4,644
views

Published on


0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
4,644
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
202
Comments
0
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. JDBC Java Database Connectivity
      • Regis Pires Magalhães
      • [email_address]
  • 2. Problema
    • Comunicação com o banco via sockets
      • Todo banco de dados possui um protocolo proprietário que pode ser acessado via sockets.
      • Poderíamos então abrir sockets diretamente com o banco de dados para realizar os comandos que desejássemos.
    • Desvantagens:
      • Lidar com a complexidade dos protolocos proprietários de banco de dados.
      • Aprender um novo protocolo para cada banco de dados que quiséssemos acessar.
  • 3. Solução
    • JDBC é uma interface para acesso a bancos de dados através de SQL.
      • Permite o acesso a bancos de dados de forma padronizada
      • Código SQL é usado explicitamente dentro do código Java
      • API única, independente do Banco de Dados
      • Pacote: java.sql
    • Para usar JDBC é preciso ter um driver JDBC
      • O banco deve ter pelo menos um driver ODBC, se não tiver driver JDBC
      • No JDK há um driver ODBC que permite o acesso a bancos
  • 4. JDBC
  • 5. Categorias de Drivers
    • Tipo 1: ponte JDBC-ODBC
      • Usam uma ponte para ter acesso a um banco de dados. Este tipo de solução requer a instalação de software do lado do cliente.
    • Tipo 2: solução com código nativo
      • Usam uma API nativa. Esses drivers contém métodos Java implementados em C ou C++. Requer software no cliente.
    • Tipo 3: solução 100% Java no cliente
      • Oferecem uma API de rede via middleware que traduz requisições para API do driver desejado. Não requer software no cliente.
    • Tipo 4: solução 100% Java
      • Drivers que se comunicam diretamente com o banco de dados usando soquetes de rede. É uma solução puro Java. Não requer código adicional do lado do cliente.
  • 6. Categorias de Drivers
  • 7. JavaDB = SUN + Apache Derby
    • A partir do Java 6 a Sun incorporou um banco de dados 100% Java chamado JavaDB.
    • Baseado no banco Derby do projeto Apache, que por sua vez veio do banco Cloudscape que foi doado ao projeto Apache pelas empresas Cloudscape, Informix e IBM.
  • 8. JavaDB = SUN + Apache Derby
    • Vantagens:
      • flexibilidade (cliente/server ou embarcado);
      • suporte das principais IDE’s (Netbeans e Eclipse).
      • Pequeno: cerca de 2MB
      • Inclui views, triggers, stored procedures e foreign keys.
      • Suporta transações multi-usuário, utilizando os principais níveis de isolação e de propriedades ACID.
      • Segurança com encriptação de dados
      • Autenticação no lado do cliente
      • Comandos GRANT e REVOKE.
      • Segue padrões como JDBC 4.0 e SQL92/99/2003/XML.
  • 9. JavaDB = SUN + Apache Derby Embarcado Cliente-Servidor
  • 10. JavaDB = SUN + Apache Derby
    • Inicializando o servidor:
      • java -jar derbyrun.jar server start
    • Executando o ij:
      • java -jar derbyrun.jar ij
      • ou
      • Pode-se colocar os arquivos derby.jar e derbytools.jar no classpath e executar o método main da classe org.apache.derby.impl.tools.ij.Main :
        • java -classpath derby.jar;derbytools.jar org.apache.derby.impl.tools.ij.Main
  • 11. JavaDB = SUN + Apache Derby
    • Usando o ij
      • ij> connect 'jdbc:derby:posbd4; create=true';
      • ij> show tables;
      • ij> CREATE TABLE clientes (id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY, cpf VARCHAR(11), nome VARCHAR(50), fone VARCHAR(10), renda DECIMAL(12, 2));
      • ij> describe clientes;
      • ij> SELECT * FROM CLIENTES;
      • ij> create table tabela1(num int, addr varchar(40));
      • ij> insert into tabela1 values (1956,'Webster St.');
      • ij> insert into tabela1 values (1910,'Union St.');
      • ij> update tabela1 set num=180, addr='Grand Ave.' where num=1956;
      • ij> select * from tabela1;
      • ij> disconnect;
      • ij> exit;
  • 12. Passos para uso do JDBC
    • Adicionar o driver JDBC ao classpath
    • Carregar a classe do driver JDBC
    • Estabelecer a conexão a partir de uma URL
    • Criar um Statement
    • Executar uma query ou update
    • Processar os resultados
    • Fechar a conexão
  • 13. Conectando com o banco
    • Adicionar o driver JDBC ao classpath
      • MySQL:
        • mysql-connector-java-5.1.6-bin.jar
      • Derby:
        • derby.jar
  • 14. Conectando com o banco
    • Carregar a classe do driver
      • Basta carregar o driver através do método Class.forName: Class.forName( "com.mysql.jdbc.Driver" ); Class.forName("org.apache.derby.jdbc.EmbeddedDriver"); Class.forName("org.apache.derby.jdbc.ClientDriver");
      • No java 6 e com driver que implementa a API JDBC 4 não é mais necessário carregar a classe para que o driver seja registrado no DriverManager.
        • Basta inserir o jar do driver no classpath e confiar no recurso de auto-discovery ou auto-loading de Driver JDBC.
      • Como o DriverManager sabe se um jar possui um driver?
        • O jar de um Driver possui o arquivo: META-INF/services/java.sql.Driver. Este arquivo armazena a classe do driver. No caso do mySQL será: com.mysql.jdbc.Driver.
  • 15. Conectando com o banco
    • Uso do driver
      • O serviço que permite o uso do driver é delegado para um gerente de drivers: o DriverManager .
    • Obtendo a conexão
      • Através do DriverManager , usamos o método getConnection com uma url que indica que banco queremos acessar.
      • O padrão da url para acessar o mysql é:
        • jdbc:mysql://host/banco
        • Exemplo: jdbc:mysql://localhost/teste
      • Exemplos de URL para acessar o derby (JavaDB) é:
        • jdbc:derby:teste; create=true
        • jdbc:derby://localhost/teste; create=true
  • 16. URL
    • A URL JDBC tem o seguinte formato:
      • jdbc:subprotocolo:dsn
        • Subprotocolo – identifica qual driver será instanciado.
        • dsn - nome que o subprotocolo usa para identificar um servidor e/ou base de dados.
    • Exemplos de URL:
      • jdbc:odbc:nomedabasededados
      • jdbc:oracle:thin@localhost:nomedabasededados
      • jdbc:postgresql://localhost/nomedabasededados
      • jdbc:mysql://localhost/nomedabasededados
      • jdbc:derby:teste; create=true
      • jdbc:derby://localhost/teste; create=true
  • 17. Conectando com o banco - MySQL import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ExemplolJDBC { public static void main(String[] args) { try { Class. forName ( "com.mysql.jdbc.Driver" ); Connection con = DriverManager. getConnection ( "jdbc:mysql://localhost/posbd4" , "root" , "root" ); System. out .println( "Conectado" ); con.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } } }
  • 18. Conectando com o banco - JavaDB import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ExemplolJDBC { public static void main(String[] args) { try { Class. forName ( "org.apache.derby.jdbc.EmbeddedDriver" ); Connection con = DriverManager. getConnection ( "jdbc:derby:posbd4; create=true" ); System. out .println( "Conectado" ); con.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } } }
  • 19. Fábrica de conexões - MySQL import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ConnectionFactory { public static Connection getConnection() throws SQLException { try { Class. forName ( "com.mysql.jdbc.Driver" ); return DriverManager. getConnection ( "jdbc:mysql://localhost/posbd4" , "root" , "root" ); } catch (ClassNotFoundException e) { throw new SQLException(e.getMessage()); } } }
  • 20. Fábrica de conexões - JavaDB import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ConnectionFactory { public static Connection getConnection() throws SQLException { try { Class. forName ( "org.apache.derby.jdbc.EmbeddedDriver" ); return DriverManager. getConnection ( "jdbc:derby:posbd4; create=true") ; } catch (ClassNotFoundException e) { throw new SQLException(e.getMessage()); } } }
  • 21. Comandos SQL
    • Opção 1
    • String sql = "insert into contatos (nome,email,endereco) values ('" + nome + "', '" + email + "', '" + endereco + "')" ;
    • Opção 2
    • String sql = "insert into contatos (nome,email,endereco) values (?,?,?)" ;
    • Vantagens da opção 2:
      • Melhor legibilidade
      • Evita SQL Injection (injeção de SQL)
      • Pode ser pre-compilada pelo SGBD
  • 22. Comandos SQL
    • A execução de comandos SQL pode ser feita via:
      • Statement
      • PreparedStatement
        • Interface que estende a interface Statement.
        • Possibilita o uso de comandos pre-compilados pelo SGBD.
        • Torna-se mais rápido quando usado repetidamente
        • Os parâmetros são representados pelo símbolo “?”.
  • 23. Executando um comando SQL // ... PreparedStatement stmt = con.prepareStatement( "insert into contatos (nome,email,endereco) values (?,?,?)" ); stmt.setString(1, "Caelum" ); stmt.setString(2, "contato@caelum.com.br" ); stmt.setString(3, "R. Vergueiro 3185 cj57" ); stmt.executeUpdate(); stmt.close(); // ...
    • O índice dos parâmetros inicia por 1.
    • Para executar o comando podemos usar os métodos:
      • boolean execute() - qualquer comando SQL
      • int executeUpdate() - DML (insert, update, delete) ou DDL.
      • ResultSet executeQuery() - Somente para consultas
  • 24. ResultSet
    • Permite navegar por seus registros através do método next().
    // ... PreparedStatement stmt = this .con.prepareStatement( &quot;select * from contatos&quot; ); ResultSet rs = stmt.executeQuery(); List<Contato> contatos = new ArrayList<Contato>(); while (rs.next()) { Contato contato = new Contato(); contato.setNome(rs.getString( &quot;nome&quot; )); contato.setEmail(rs.getString( &quot;email&quot; )); contato.setEndereco(rs.getString( &quot;endereco&quot; )); contatos.add(contato); } rs.close(); stmt.close(); return contatos;
  • 25. Result Set
    • O método executeQuery(), da interface Statement, retorna um objeto ResultSet.
      • Cursor para as linhas de uma tabela
      • Pode-se navegar pelas linhas da tabela recuperar as informações armazenadas nas colunas
    • Os métodos de navegação são: next(), previous(), absolute(), first() e last()
    • Métodos para obtenção de dados: getInt(), getString(), getDate()...
  • 26. Recuperando dados de ResultSets
    • Métodos getXXX
      • Usam-se métodos dos ResultSets come çados por get
      • Recuperam um dado de acordo com o tipo
      • Como parâmetros podem ser usados a posição do campo (començando de 1) ou o nome do campo na tabela
    • Ex: rs. getInt( “codigo” ) ou rs.getInt(1) rs. getString( “descricao” ) ou rs.getString(2)
  • 27. Recuperando dados de ResultSets getBigDecimal() DECIMAL
  • 28. Passos para uso do JDBC
    • 1. Carregar o driver 2. Estabelecer uma conexão com o BD 3. Criar uma declaração (PreparedStatement) e setar os parâmetros 4. Executar o comando ou consulta SQL 5. Processar o resultado 6. Fechar a conexão Em Java: 1. Class.forName(&quot;com.mysql.jdbc.Driver&quot;); 2. Connection con = DriverManager.getConnection (&quot;jdbc:mysql://localhost/teste&quot;, &quot;root&quot;,&quot;root&quot;); 3. PreparedStatement ps = con.prepareStatement(); 4.1. ps.executeUpdate(&quot;delete from Produtos&quot;); // ou 4.2. ResultSet rs = ps.executeQuery(&quot;select * from Produtos&quot;); 5. while(rs.next()) {       System.out.println(“Cód.: &quot; + rs.getString(1) + &quot; Desc: &quot; + rs.getString(2));     } 6. con.close();
  • 29. Fechando recursos
    • Statements, PreparedStatements, ResultSets e Connections possuem um método close().
    • Sempre que esses recursos não forem mais utilizados, é importante fechá-los.
    • Ao fechar a conexão, PreparedStatements e ResultSets que estão associados à conexão serão automaticamente fechados.
    • Exemplo de tratamento de exceções:
    try { // ... } catch (SQLException e) { // ... } finally { try { con.close(); } catch (SQLException e) { // ... } }
  • 30. Transações
    • Para permitir a criação de transações com mais de um comando, o modo de auto-commit deve ser desabilitado
    • O método setAutoCommit deve ser invocado no objeto do tipo Connection passando-se o valor false para ele
      • con.setAutoCommit(false) ;
    • Para realizar, respectivamente, o commit ou o rollback em uma transação utilize os seguintes métodos do objeto Connection:
      • con.commit()
      • con.rollback()
    • Nota : a pós terminar o uso de uma conexão, feche-a invocando o método close() da mesma
  • 31. Fechando recursos com uso de transação // ... Connection conn = null; try { conn = ConnectionFactory.getConnection(); conn.setAutoCommit( false ); // ... conn.commit(); } catch (SQLException ex) { try { conn.rollback(); } catch (SQLException e) { // ... } } finally { try { conn.close(); } catch (SQLException ex){ // ... } }
  • 32. DataSource
    • Representa uma fábrica de conexões para o banco de dados físico
      • Alternativa ao mais adequada ao uso DriverManager
      • Sua implementação é de responsabilidade do fornecedor do banco de dados
        • Implementação Básica – cria conexões físicas da mesma forma do DriverManager
        • Implementação de Pool de Conexões – cria conexões que participarão de um pool (esta abordagem é usada em aplicações multi-camadas)
        • Implementação de Transações Distribuídas – semelhante à anterior exceto pelo fato de trabalhar com transações distribuídas
  • 33. DataSource
    • ...
    • DataSource ds = new OracleConnectionPoolDataSource(url);
    • ds.getConnection(user, password);
    • ...
    ... Context initContext = new InitialContext(); Context envContext = (Context)initContext.lookup( &quot;java:/comp/env&quot; ); DataSource ds = (DataSource)envContext.lookup( &quot;jdbc/cefet&quot; ); conn = ds.getConnection()); ...
  • 34. RowSet
    • javax.sql.RowSet
      • Interface disponível a partir do JDBC 3.
      • CachedRowSet pode ser usado em modo desconectado, permitindo acesso ao banco mesmo após o fechamento da conexão. Depois, pode ser retornado ao servidor para sincronização com a base de dados.
      • WebRowSet permite manipular dados de origem não-relacional (XML).
      • RowSets são uma boa representação de dados tabulares.
  • 35. Versões do JDBC
    • Java 1.1 – JDBC 1.0
    • Java 1.2 – JDBC 2.0
      • Interface DataSource para conexões gerenciadas por containers JEE;
      • Suporte a transações distribuídas;
      • Interface RowSet, que permite cache do resultado de consultas no cliente.
    • Java 1.3 – JDBC 2.1
      • Atualizações em batch para envio de vários comandos SQL de uma só vez;
      • Suporte a resultados roláveis (scrollable) e atualizáveis para navegação livre por um ResultSet;
      • Atualização direta do registro corrente em um ResultSet, sem necessidade de enviar comandos de SQL update;
      • Mapeamento de tipos definidos pelo usuário.
  • 36. Versões do JDBC
    • Java 1.4 – JDBC 3
      • Save points, que permitem rollback parcial de uma transação;
      • Parâmetros nomeados em stored procedures;
      • Forma padronizada de obter o valor de campos gerados automaticamente pelo banco (identity e autoincrement).
  • 37. Versões do JDBC
    • Java 6 – JDBC 4
      • Auto-loading de driver JDBC;
      • Maior controle sobre pool de conexões e comandos;
      • Suporte ao tipo rowid (identif. Física de registros em alguns bancos como Oracle);
      • Suporte ao padrão SQL 2003;
      • Exceções mais específicas e não somente SQLException;
      • Manipulação de XML e suporte a extensões do SQL para dados XML.
  • 38. Versões do JDBC
    • A proposta original do JDBC 4.0, incluído no Java 6, disponibilizava novas interfaces Query e DataSet apoiadas por anotações para mapear diretamente operações sobre o banco para métodos e atributos de classes.
    • Infelizmente esse recurso foi cancelado, pois sua implementação estava atrasada e a Sun não queria atrasar a release final do Java 6 que trouxe o JDBC 4.
    • Talvez esse recurso seja incluído no Java 7.
  • 39. Versões do JDBC class User { int userID ; String name ; String department ; } interface MyQueries extends BaseQuery { @ Query(sql= &quot;select * from user&quot; ) DataSet getAllUsers(); @ Query(sql= &quot;select * from user where department= {department}&quot; ) DataSet getDepartmentUsers(String department); @ Update(sql= &quot;delete from user where name= {userName}&quot; ) int deleteUser(String userName); @ Update(sql= &quot;update user set department={department} where &quot; + &quot;name= {userName}&quot; ) int updateDeparment(String userName, String department); }
  • 40. Versões do JDBC ... Connection c = myDataSource.getConnection(); MyQueries q = c.createQueryObject(MyQueries. class ); DataSet users = q.getAllUsers(); for (User u: users) { System.out.println( &quot;User's name is: &quot; + user.name; } ... ... Connection c = myDataSource.getConnection(); MyQueries q = c.createQueryObject(MyQueries. class ); DataSet users = q.create(); User user = new User(); user.setUserID(1); user.setName( &quot;Joe&quot; ); user.setDeparment( &quot;Accounting&quot; ); users.insert(user); ...
  • 41. Referências
    • Apostila da Caelum FJ-21 – Java para desenvolvimento Web – Capítulo 2 - JDBC
    • JDBC na Wikipedia:
      • http://pt.wikipedia.org/wiki/JDBC
    • Java com DB na Sun:
      • http://java.sun.com/javase/technologies/database/
    • Encontrando Drivers JDBC
      • http://developers.sun.com/product/jdbc/drivers
    • Página sobre o uso de Java com MySQL
      • http://dev.mysql.com/usingmysql/java/