Usando SQLite com Java no Eclipse

From CInLUG

Conteúdo

1 Cenário
2 SQLite
- 2.1 Ferramentas
- 2.2 Java
3 Recordes
- 3.1 Classes
- 3.2 Eclipse
  - 3.2.1 Executando
4 E Pra Acabar...
- 4.1 Outras Referências

Cenário

Nos cursos de computação do Centro de Informática temos duas disciplinas um tanto relacionadas entre si: Gerenciamento de Dados e Informação (ou GDI) e Engenharia de Software e Sistemas (doravante chamada de ES). É prática comum dos grupos de alunos usarem o mesmo projeto para as duas disciplinas e ganhar (ou deixar de perder) algum tempo. Para meu grupo o problema começou quando vimos que não poderíamos usar toda a camada de dados da nossa aplicação pois por alguns motivos não teríamos como usar o servidor de banco de dados usado em GDI na versão do projeto para disciplina de ES. Em vez de rescrever tudo acessando arquivos de texto, preferimos experimentar SQLite. Como tudo que se faz nesse departamento é em Java, este é um breve tutorial de como usar SQLite com a linguagem da Sun na plataforma Eclipse.

SQLite

Segundo o site oficial, SQLite é uma pequena biblioteca em C que implementa um sistema de gerenciamento de banco de dados relacional que aceita comandos SQL. Por se tratar de uma biblioteca bem pequena (cerca de 200Kb), é muito usada em sistemas embutidos, e a página do SQLite na wikipedia possui uma lista de aplicações que usam a biblioteca, até mesmo o OpenOffice.org.

Visite o site oficial para:

Ferramentas

Existem diversas ferramentas para manipular bases de dados (arquivos) SQLite, inclusive do tipo Web, via linguagens como PHP ou Python. Se você quiser brincar um pouco com SQLite sem programar, pode instalar o terminal sqlite. Se estiver no Debian/Ubuntu, o pacote é sqlite3, ou se estiver no MS Windows, pode baixá-lo aqui sqlite-3_3_7.zip. Depois de instalar, chame o terminal sqlite3 na linha de comando, então .help para ver o que pode fazer. Obviamente, conhecimentos de SQL são um pré-requisito.

Java

Como disse antes, o objetivo deste tutorial é usar SQLite com Java. No site SQLiteJDBC podemos encontrar wrappers do SQLite para Java nas plataformas Linux, Windows e Mac OS X. Os arquivos são um .jar e um .so (ou .dll para o Windows) que devem ser incluídos com os fontes da aplicação que faz uso da biblioteca. Baixe o pacote para o ambiente desejado (ou mais de um) e descompacte em algum lugar, agora vamos para próxima parte desse tutorial.

Recordes

Diagrama ER.

Pra ficar minimamente interessante vamos criar uma aplicação de demonstração do SQLite em Java: um banco de dados de recordes em jogos de videogame. Não é grandes coisas, não tem utilidade prática, mas ei!, isso é um tutorial, e um demo é melhor que nada. :P

Classes

O projeto SQLiteDemo é composto de apenas 3 classes, a mais interessante é a DBConnection, onde acontece a interação com o banco de dados, via JDBC.

HiScore

Diagrama UML do objeto HiScore que representa uma linha na tabela HiScores do banco de dados.

Esta é apenas uma classe de dados básica, que poderia muito bem ser substituída por uma string e um inteiro, mas vamos fazer a coisa do jeito certo, com atributos privados e get/sets.

public class HiScore {
  private String jogo;
  private int score;
  
  public HiScore(String jogo, int score) {
    this.jogo = jogo;
    this.score = score;
  }
 
  public String getJogo() {
    return jogo;
  }
 
  public void setJogo(String jogo) {
    this.jogo = jogo;
  }
 
  public int getScore() {
    return score;
  }
 
  public void setScore(int score) {
    this.score = score;
  }
}

DBConnection

Com esta classe e mais R$ 1,00 você pode tomar um refrigerante em qualquer birosca.

Esta classe abstrai o acesso ao banco de dados para qualquer entidade que a utilizar, oferecendo apenas operações de inserção, remoção e atualização de dados; se por debaixo roda um bd controlado pelo SQLite, uma planilha ou um simples arquivo CSV (Comma-Separated Values), não interessa a quem chama.

Os métodos são explicados nos comentários no próprio código.

import java.sql.*;
import java.util.Vector;
 
public class DBConnection {
  private Connection conn;
  private Statement stm;
  
  /**
   * O construtor cria uma nova conexão com o banco de dados sqlite contido
   * no arquivo passado como parâmetro. A conexão é possibilitada pelo driver
   * JDBC, fornecido por SQLiteJDBC.
   */
  public DBConnection(String file) throws SQLException, ClassNotFoundException {
    Class.forName("org.sqlite.JDBC");
    this.conn = DriverManager.getConnection("jdbc:sqlite:" + file);
    this.stm = this.conn.createStatement();
  }
  
  /**
   * Cria uma nova tabela de recordes, apagando tudo que houvesse na base
   * anteriormente.
   */
  public void initDB() {
    try {
      this.stm.executeUpdate("DROP TABLE IF EXISTS Recordes");
      this.stm.executeUpdate("CREATE TABLE Recordes (" +
          "jogo varchar(50) PRIMARY KEY NOT NULL," +
      "score integer);");
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
  
  /**
   * Adiciona uma nova linha na tabela de recordes.
   * @param score
   */
  public void addHiScore(HiScore score) {
    try {
      this.stm = this.conn.createStatement();
      this.stm.executeUpdate("INSERT INTO Recordes VALUES (\"" +
          score.getJogo() + "\"," + 
          String.valueOf(score.getScore()) + ")");
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
  
  /**
   * Remove a linha da tabela cuja coluna "jogo" seja igual a string passada
   * como parâmetro. 
   * @param jogo
   */
  public void removeHiScore(String jogo) {
    try {
      this.stm = this.conn.createStatement();
      this.stm.executeUpdate("DELETE FROM Recordes WHERE " +
          "jogo=\"" + jogo + "\"");
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
  
  /**
   * Altera o valor de uma linha do banco de dados.
   * @param hiScore
   */
  public void atualizaHiScore(HiScore hiScore) {
    try {
      this.stm = this.conn.createStatement();
      this.stm.executeUpdate("UPDATE Recordes SET score=\"" +
          String.valueOf(hiScore.getScore()) + "\"" +
          "WHERE jogo=\"" + hiScore.getJogo() + "\"");
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
  
  /**
   * Retorna um objeto Vector com todos os recordes do banco de dados
   * organizados em ordem decrescente de pontuação.
   * @return
   */
  public Vector getAll() {
    Vector hiScores = new Vector();
    ResultSet rs;
    try {
      rs = this.stm.executeQuery("SELECT * FROM Recordes " +
      "ORDER BY score DESC");
      while (rs.next()) {
        hiScores.add(new HiScore(rs.getString("jogo"), rs.getInt("score")));
      }
      rs.close();
    } catch (SQLException e) {
      e.printStackTrace();
    }
    
    return hiScores;
  }
}

Demo

Esta classe existe apenas para testar as operações de DBConnection. Ela insere três recordes, mostra o conteúdo do banco, altera uma linha, remove outra, e mostra novamente todos os recordes.

import java.util.Iterator;
 
public class Demo {
  public static void main(String[] args) {
    try {
      DBConnection dbCon = new DBConnection("hiscores.db");
      
      dbCon.initDB();
      dbCon.addHiScore(new HiScore("Duck Tales", 800000));
      dbCon.addHiScore(new HiScore("Quackshot", 220000));
      dbCon.addHiScore(new HiScore("Metroid", 12345678));
      
      Demo.imprimeLista(dbCon);
      
      dbCon.atualizaHiScore(new HiScore("Quackshot", 99999999));
      dbCon.removeHiScore("Metroid");
      
      Demo.imprimeLista(dbCon);
      
    } catch (Exception e) {
      e.printStackTrace();
    }  
  }
  
  public static void imprimeLista(DBConnection dbCon) {
    Iterator it = dbCon.getAll().iterator();
    HiScore hs;
    System.out.println("---------------------");
    while(it.hasNext()) {
      hs = (HiScore) it.next();
      System.out.println("Jogo.:" + hs.getJogo());
      System.out.println("Score:" + String.valueOf(hs.getScore()));
      System.out.println();
    }
  }
}

Eclipse

Vamos ao roteiro para criar um projeto no Eclipse e configurá-lo adequadamente para desfrutarmos do SQLite.

Abra o Eclipse e crie um novo projeto Java com o nome "SQLiteDemo". Copie os arquivos sqlitejdbc.jar e libsqlitejdbc.so (ou libsqlitejdbc.dll, ou ainda os dois se quiser ser multiplataforma) para o diretório do projeto, ou simplesmente arraste e solte os arquivos sobre o nome do projeto no Package Explorer do Eclipse.

Ainda no Package Explorer, clique com o botão direito sobre o nome do projeto, e no menu escolha "Properties".

Na janela de propriedades do projeto, escolha o item "Java Build Path" e em seguida a aba "Libraries". Clique no botão "Add JARs", procure a entrada com o nome "SQLiteDemo", e sob ela uma entrada "sqlitejdbc.jar". De volta à janela de propriedades do projeto, expanda a entrada "sqlitejdbc.jar", escolha "Native library location: (None)" e clique no botão "Edit...". Na janela "Native Library Folder Configuration" que irá surgir, clique no botão "Workspace", na lista apresentada escolha novamente "SQLiteDemo". Agora basta clicar em "OK" na janela de propriedades do projeto e começar a usar SQLite sabor Java.

Executando

Dentro do projeto, crie as classes mostradas anteriormente e execute a partir da classe Demo, a saída deve ser esta aqui:

---------------------
Jogo.:Metroid
Score:12345678

Jogo.:Duck Tales
Score:800000

Jogo.:Quackshot
Score:220000

---------------------
Jogo.:Quackshot
Score:99999999

Jogo.:Duck Tales
Score:800000

E Pra Acabar...

SQLiteDemo.zip

Ao lado está o download do projeto "SQLiteDemo", completo, com o driver SQLite e tudo mais. Para importá-lo no seu workspace do Eclipse, vá em File->Import, escolha Archive File e indique o arquivo com o código deste tutorial.