Exemplo de Aplicação Java Swing com BD Oracle - 1

Hoje vamos iniciar uma série de artigos que culminarão com uma pequena aplicação exemplo de gestão de biblioteca, feita em Java, para ambiente desktop usando classes Java Swing, e acedendo a uma base de dados (BD) Oracle.

Este primeiro artigo trata da criação de uma pequena Base de Dados em Oracle. Foi usado o Oracle Express 10g, o qual pode ser downloaded gratuitamente em http://www.oracle.com/technetwork/database/express-edition/downloads/102xewinsoft-090667.html. Há já uma versão mais recente do Oracle Express, a 11g release 2, a qual pode ser obtida em http://www.oracle.com/technetwork/database/express-edition/downloads/index.html e com a qual o exemplo também deverá funcionar.

Após a instalação do Oracle, podemos aceder à ferramenta de administração da base de dados indo ao botão Iniciar --> Todos os Programas --> Oracle Database 10g Express Edition --> Ir para a Home Page de Banco de Dados  ou, num browser, ir a http://localhost:8080/apex.

Deverá, então, aparecer uma página para efectuarmos o login na ferramenta de administração:

Devemos entrar com o utilizador SYSTEM e a password que definimos para esse utilizador durante o processo de instalação.Após entrar aparece-nos o ambiente de trabalho:

Neste ponto, devemos, primeiramente, criar um utilizador (Administration --> Database Users --> Create User). Criámos o utilizador libraryuser, o qual irá ser, depois, usado para criar as tabelas da BD e também para aceder à BD a partir da aplicação Java. É necessário dar-lhe permissão de CREATE TABLE e CREATE SEQUENCE, podendo também ser-lhe dada permissão para CREATE VIEW, CREATE PROCEDURE, e CREATE TRIGGER.

O user com que são criadas as tabelas da base de dados irá ficar como prefixo da tabela (schema) e, dependendo dos direitos de acesso, pode ficar restringido a ver apenas as "suas" tabelas.

A referencia a uma coluna de uma tabela, em Oracle, tem a seguinte estrutura:

"schema"."table"."column" 

O schema pode ter 30 bytes, o nome da tabela mais 30 bytes, e o nome da coluna mais 30 bytes.O comprimento total máximo de um identificador de coluna é, portanto, de 98 bytes (se contarmos os pontos e aspas).

Não devemos, portanto, usar o user SYSTEM para criar tabelas de utilizador, e muito menos para aceder à base de dados a partir de uma aplicação.

Claro que para uma aplicação brinquedo isso não é importante.

O passo seguinte será, então, fazer logout de SYSTEM na ferramenta de administração, e fazer login com o novo user criado (libraryuser).

Agora, podemos criar as tabelas da nossa base de dados, as quais irão ficar com schema libraryuser, pois é esse o utilizador que vamos usar na sua criação.

Queremos criar as tabelas conforme o seguinte esquema de BD:

No próximo artigo iremos criar uma classe em Java para aceder à base de dados criada.Se tiverem problemas, coloquem as vossas perguntas nos comentários a este artigo.

Exemplo de Aplicação Java Swing com BD Oracle - 2

No artigo anterior iniciámos a construção de uma série de artigos para a construção de uma pequena aplicação exemplo de gestão de biblioteca, para ambiente desktop usando classes Java Swing, e acedendo a uma base de dados (BD) Oracle.

O artigo anterior tratou da criação da Base de Dados em Oracle.Este artigo vai tratar da construção de uma classe Java para acesso à Base de Dados.

Iremos usar o NetBeans IDE 7.0.1, o qual pode ser downloaded de http://netbeans.org/community/releases/70/.

Após instalar o NetBeans IDE 7.0.1, devemos criar um novo projecto "Java Class Library", ao qual vamos chamar HelperDB, pois irá tratar-se apenas de uma classe de acesso à base de dados.

  Criamos uma classe Java, a que chamamos DBAccessObj, a qual ficará no ficheiro DBAccessObj.java.

É necessário incluir as bibliotecas de classes JAR para acesso por driver ODBC à base de dados Oracle:

Estes ficheiros jar devem estar presentes na directoria

                              oraclexe\app\oracle\product\10.2.0\server\jdbc\lib

sendo oraclexe a directoria onde foi instalado o Oracle XE.

Vamos criar um package, a que chamamos HelperDB, que irá conter a nossa classe, e vamos importar o package java.sql, o qual contém classes de conexão e envio de statements SQL à base de dados:

package HelperDB;

import java.sql.*;

public class DBAccessObj{       private Connection conn;

       public DBAccessObj()       {

       }}

Como única variável de instância da nossa classe, criamos conn do "tipo" java.sql.Connection.Na verdade, Connection é uma interface que poderá conter um objecto de qualquer tipo que implemente essa interface. Assim, conn poderá conter uma instância de uma conexão de qualquer tipo. O tipo será dado pelo DriverManager de acordo com o driver que for utilizado.

O construtor da classe será então modificado para criar uma conexão à base de dados:

       public DBAccessObj()       {              this.createDBConnection();       }

       private void createDBConnection()       {            try {                     Class.forName("oracle.jdbc.driver.OracleDriver");            }            catch(ClassNotFoundException e) {                     System.out.println("Oops! Can't find class oracle.jdbc.driver.OracleDriver");                     System.exit(1);            }            try{                     conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "libraryuser","libraryuser");            }            catch(Exception e){                     System.out.println("ERRO " + e.getMessage());            }       }

O driver a usar é o "oracle.jdbc.driver.OracleDriver" e a string de ligação à base de dados é:

"jdbc:oracle:thin:@localhost:1521:XE"

sendo "libraryuser","libraryuser", respectivamente o user e password do utilizador que queremos usar no acesso à base de dados (ver artigo anterior).

Neste ponto, se fizermos uma pequena classe de teste (TestClass.java) para criar uma instância da nossa classe, já será possível ver se a conexão é possível:

import HelperDB.DBAccessObj;

public class TestClass {    public static void main(String[] args) {        DBAccessObj conexao = new DBAccessObj();            }}

Se não for possível, aparecerá uma das mensagens de erro que damos num dos catchs acima.

Depois de criar a conexão à base de dados queremos enviar statements SQL para inserir dados numa tabela (INSERT), alterar dados (UPDATE), apagar dados (DELETE) ou consultar dados (SELECT).

Para isso temos que ter uma instância de uma classe que implemente a interface java.sql.Statement:

       public  Statement   createStatement()       {          Statement st=null;          if (this.conn==null)                   this.createDBConnection();          try{                   st = this.conn.createStatement();          }          catch(Exception e){                   System.out.println("ERRO " + e.getMessage());          }          return st;       }

Para executar um comando SQL usando a instância de Statement, vamos criar mais uns métodos na nossa classe:

- Para executar um comando SQL que não devolve resultado (INSERT, UPDATE ou DELETE):

       public void executeSQL(String SqlComm)       {        Statement st = this.createStatement();        try{                   st.execute(SqlComm);              }

          catch(Exception e){                   System.out.println("ERRO " + e.getMessage());          }

       }

- Para executar um comando SQL que devolve um resultado (SELECT):

       public ResultSet  executeQuery(String SqlComm)       {          Statement st = this.createStatement();          ResultSet rs=null;

          try{                   rs = st.executeQuery(SqlComm);          }          catch(Exception e){                   System.out.println("ERRO " + e.getMessage());          }          return rs;       }

Por fim, vamos escrever métodos para criar uma conexão e eliminar uma conexão:

       public Connection  openConnection()       {           if(this.conn==null)                     this.createDBConnection();

           return this.conn;       }

       public void   closeConnection()       {              if(this.conn!=null)              {                  try{                            this.conn.close();                   }                   catch(Exception e){                            System.out.println("ERRO " + e.getMessage());                   }              }       }

Isto termina a nossa classe. Para a testar, podemos agora melhorar a nossa classe de teste:

import HelperDB.DBAccessObj;import java.sql.*;

public class TestClass {    public  static  void  main(String[] args) {             DBAccessObj conexao = new DBAccessObj();                    conexao.executeSQL("Insert into Author columns (Name, SURNAME) VALUES ('XICO', 'MENDES')");                    ResultSet rs = conexao.executeQuery("SELECT * FROM AUTHOR");                    try{                    while(rs.next()){                           String aName = ((String)rs.getString("Name"));                           String aSurname = ((String)rs.getString("Surname"));                           //                           System.out.println(aName + " " + aSurname);                    }             }             catch(Exception e){                     System.out.println("ERRO " + e.getMessage());             }    }}

Se tudo estiver bem, o resultado do teste será a inserção do autor com nome XICO MENDES na tabela AUTHOR e a posterior listagem do conteúdo da mesma tabela.Não foram testados os métodos de criar e fechar a conexão, mas veremos a sua utilidade noutro artigo.

Exemplo de Aplicação Java Swing com BD Oracle – 3

Hoje, vamos desenvolver uma biblioteca de classes que mapeia os conceitos do domínio do problema, e faz a ponte entre a interface com o utilizador, cujo desenvolvimento trataremos no próximo artigo, e a camada de persistência de dados, tratada no primeiro artigo desta série.

Esta camada com conceitos e operações do domínio do problema é comummente chamada de camada intermédia ou camada de lógica do negócio.

Podemos considerar que o nosso pequeno sistema aplicacional terá, então, uma arquitectura de software em 3-camadas (abordaremos o tema da arquitectura de software num artigo futuro).

Há várias maneiras de desenvolver esta camada intermédia, a qual pode ela própria conter uma ou mais camadas. Nós iremos desenvolver uma classe para cada conceito do domínio, o que corresponde, mais ou menos, neste pequeno exemplo, a desenvolver uma classe para cada tabela da base de dados.

Há várias maneiras de fazer isso. Em particular, vamos ver duas possíveis maneiras, cada uma com o seu grupo de defensores, e com as suas próprias vantagens e desvantagens.

1 – Há autores que defendem o desenvolvimento de uma camada de classes apenas com atributos, getters e setters (ex.: classe Book abaixo), separadamente de uma camada de classes com operações com significado para o negócio (ex.: classe BookBLL abaixo).

1.1 classe Book:public class Book {    private int idBook;    private String title;    private String editor;    private java.sql.Date date;    private String ISBN;    private String edition;    //    private List<Author> authors = new ArrayList<Author>();

        public Book() {    }

    public int getID() {  return this.idBook;    }

    public void setTitle(String title) {  this.title = title;    }

    public String getTitle() {  return title;    }

    public void setEditor(String editor) { this.editor = editor;    }

    public String getEditor() {  return editor;    }

    public void setDate(java.sql.Date date) {  this.date = date;    }

    public java.sql.Date getDate() {  return date;    }

    public void setISBN(String ISBN) {  this.ISBN = ISBN;    }

    public String getISBN() {  return ISBN;    }

    public void setEdition(String edition) {  this.edition = edition;    }

    public String getEdition() {  return edition;    }

    public List<Author> getAuthors() {  return this.authors;    }}

1.2 classe BookBLL:

public class BookBLL {    private DBAccessObj dbo;

    public BookBLL() {        this.dbo = new DBAccessObj();        this.dbo.openConnection();    }

    public BookBLL(DBAccessObj dbo) {        this.dbo = dbo;        this.dbo.openConnection();    }

     public void create(Book b) throws SQLException{

            String sqlCommand =                         "INSERT INTO Book (ISBN, Title, Edition, Editor) VALUES('" +                                                                 b.getISBN() + "', '" + b.getTitle() + "', '" +                                                                 b. getEdition() + "', '" + b.getEditor() + "')";

            this.dbo.executeSQL(sqlCommand);     }

…// restantes operações…}

Esta primeira abordagem não explora o encapsulamento de dados e operações sobre os dados (conceito fundamental do paradigma de programação orientado a objetos).

2 – Outra maneira, é desenvolver:•    uma camada de classes com atributos, getters e setters, mais as operações CRUD (Create, Retrieve, Update, Delete) (ex.: class BookDAL abaixo); separadamente de,•    uma camada de classes com operações com significado para o negócio, e que não dependem directamente da base de dados e podem ser obtidas por composição das operações CRUD primitivas (ex.: class BookBLL abaixo).

2.1 classe BookDAL:

public class BookDAL {    private int idBook;    private String title;    private String editor;    private java.sql.Date date;    private String ISBN;    private String edition;    //    private List<Author> authors = new ArrayList<Author>();        private DBAccessObj dbo;

    public BookDAL() {        this.dbo = new DBAccessObj();        this.dbo.openConnection();    }

    public BookDAL(DBAccessObj dbo) {        this.dbo = dbo;        this.dbo.openConnection();    }

    public int getID() {  return this.idBook;    }

    public void setTitle(String title) {  this.title = title;    }

    public String getTitle() {  return title;    }

    public void setEditor(String editor) { this.editor = editor;    }

    public String getEditor() {  return editor;    }

    public void setDate(java.sql.Date date) {  this.date = date;    }

    public java.sql.Date getDate() {  return date;    }

    public void setISBN(String ISBN) {  this.ISBN = ISBN;    }

    public String getISBN() {  return ISBN;    }

    public void setEdition(String edition) {  this.edition = edition;    }

    public String getEdition() {  return edition;    }

    public List<Author> getAuthors() {  return this.authors;    }

    public void create() throws SQLException{              String sqlCommand =                         "INSERT INTO Book (ISBN, Title, Edition, Editor) VALUES('" +                          this.ISBN + "', '" + this.title + "', '" + this.edition + "', '" + this.editor + "')";              this.dbo.executeSQL(sqlCommand);    }

    public void retrieve(int id) throws SQLException{         String sqlCommand =            "SELECT ISBN, Title, DateEdition, Edition, Editor FROM Book WHERE ID = '" + id + "'";

         ResultSet book;

         book = this.dbo.executeQuery(sqlCommand);                 if (book.next()){                    this.idBook = id;                    this.ISBN = book.getString("ISBN");                    this.title = book.getString("Title");                    this.date = book.getDate("DateEdition");                    this.edition = book.getString("Edition");                    this.editor = book.getString("Editor");         }    }

    public void retrieveByISBN(String isbn) throws SQLException{        String sqlCommand =         "SELECT ID, Title, DateEdition, Edition, Editor FROM Book WHERE ISBN = '" + isbn + "'";

        ResultSet book;

        book = this.dbo.executeQuery(sqlCommand);                 if (book.next()){             this.idBook = book.getInt("ID");             this.title = book.getString("Title");             this.date = book.getDate("DateEdition");             this.edition = book.getString("Edition");             this.editor = book.getString("Editor");             this.ISBN = isbn;        }    }

    public void update() {        String sqlCommand =             "UPDATE Book SET ISBN = '" + this.ISBN + "', Title = '" + this.title + "', Edition = '" +                   this.edition + "', Editor = '" + this.editor + "' WHERE ID = '" + this.idBook + "'";

        this.dbo.executeSQL(sqlCommand);    }

    public void delete() {        String sqlCommand = "DELETE FROM Book WHERE ID = '" + this.idBook + "'";        this.dbo.executeSQL(sqlCommand);    }

    public ResultSet retrieveThisBookAuthors(DBAccessObj dbo) throws SQLException{        String sqlCommand =              "SELECT B.ID, B.ISBN, B.Title, A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID AND B.ID = " + this.getID() + " ORDER BY 3, 2";

        ResultSet books;

        dbo.openConnection();        books = dbo.executeQuery(sqlCommand);        return books;    }

    public void fillThisBookAuthors() throws SQLException{        String sqlCommand = "SELECT A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID AND B.ID = " + this.getID() + " ORDER BY 3, 2";        ResultSet booksA;

        this.dbo.openConnection();        booksA = this.dbo.executeQuery(sqlCommand);

        while (booksA.next()){            Author au = new Author();            au.setName(booksA.getString("Name"));            au.setSurname(booksA.getString("Surname"));            this.authors.add(au);        }

    }

    public static ResultSet retrieveAllBooks(DBAccessObj dbo) throws SQLException{        String sqlCommand = "SELECT ISBN, Title, DateEdition, Edition, Editor FROM Book";        ResultSet books;

        dbo.openConnection();        books = dbo.executeQuery(sqlCommand);        return books;    }

    public static ResultSet retrieveAllBooksAuthors(DBAccessObj dbo) throws SQLException{

        String sqlCommand = "SELECT B.ID, B.ISBN, B.Title, A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID ORDER BY 1, 6, 5";        ResultSet books;

        dbo.openConnection();        books = dbo.executeQuery(sqlCommand);        return books;    }

2.2 classe ManageBooksBLL:

public class ManageBooksBLL {    public ManageBooksBLL () {    }

    public int requisitarBook (Book book, Borrower leitor)  throws  ManageBookException {

          …    }

    public int requisitarBook (int bookID, int leitorID)  throws  ManageBookException {          …    }

    public int devolverBook (Book book)  throws  ManageBookException{          …    }

    public int devolverBook (int bookID)  throws  ManageBookException {          …    }}

Nesta abordagem, o encapsulamento de dados e operações aparece, orientado às entidades do domínio do problema (classes Entidade ou persistentes), na camada DAL.

A camada BLL (Business Logic Layer) contém operações orientadas aos casos de uso a implementar na aplicação, podendo portanto ser vista como uma camada de fornecimento de serviços para a camada acima, de Interface com o utilizador (UI, User Interface).

Em termos práticos, dependendo da quantidade de operações complexas num programa (diferentes de CRUD), podemos ainda misturar a DAL e BLL da 2ª abordagem, passando isso por acrescentar nas classes DAL os poucos métodos BLL que tivéssemos, eliminando as classes BLL.

De notar, em ambas as abordagens, a utilização da classe DBAccessObj, cujo desenvolvimento foi tratado no artigo anterior, para acesso à base de dados.

O zip com o resultado final pode, como de costume, ser solicitado nos comentários a este artigo.

Exemplo de Aplicação Java Swing com BD Oracle – 4

Neste artigo vamos desenvolver a camada de apresentação, ou de Interface com o utilizador, para a aplicação que vem sendo desenvolvida há algum tempo.

No artigo Exemplo de Aplicação Java Swing com BD Oracle - 1, o 1º desta série, tratámos da criação da Base de Dados em Oracle. No 2º artigo, foi criada um package para acesso à base de dados, HelperDB. O 3º artigo tratou da criação de uma biblioteca de classes ao nível da lógica de negócio e acesso a dados.

Este artigo vai tratar da criação do projecto de Interface com o utilizador (GUI - Graphical User Interface) usando classes Swing. Para isso, vamos criar um novo projecto no Net Beans, chamado LibrarySystem:

Este projecto deve ser um Java Desktop Application. Este tipo de projecto fornece um template com a infraestrutura básica de uma aplicação desktop, tal como uma janela principal com uma barra de menu e uma barra de estado.

Depois, vamos seleccionar Basic Application (o outro tipo, Database Application, iremos abordar numa outra série de artigos).

Este tipo de projecto cria de antemão 3 classes:- LibrarySystemApp.java - é a classe principal da aplicação. A main irá lançar a janela principal. A partir daí, toda a aplicação será guiada por eventos.

- LibrarySystemView.java - é a janela principal:

- LibrarySystemAboutBox.java - é uma janela About (Acerca de...).

Na janela com a vista de projectos podemos ver o novo projecto, assim como os que criámos anteriormente. Para mantêr uma lógica nos nomes dos projectos, alterámos o nome deste projecto para  libraryProjectGUI:

1. Construção da interface (GUI)A partir da Pallete (onde estão os Swing containers, Swing controls, Swing Windows, etc.), arrastamos os objectos de interface que pretendemos ver nas janelas da interface.

Aqui, vamos fazer toda a aplicação na mesma janela.Vamos começar por acrescentar menus (JMenu) e itens de menu (JMenuItem) na barra de menus que já temos inicialmente.

Criamos um item de menu, Initial Panel, no menu File, que nos permitirá voltar ao ecrã inicial:

E criamos um novo menu, Books, com um item de menu, Manage Books, o qual nos levará à lista e manutenção de livros da biblioteca:

Chegou, então o momento de criar novos painéis (JPanel) que substituirão o painel inicial na janela da aplicação.Criamos um novo painel para criação e edição de um livro:

E, criamos um painel para listar os livros existentes:

2. Criação de métodos para tratamento de eventos despoletados na GUI

Vamos agora fazer trocar o painel visível, quando é selecionada a opção de menu Manage Books do menu Books.

Quando ocorre um evento "selecionar o item de menu" queremos correr um método para fazer a troca de painéis. Temos duas maneiras de o fazer:

2.1 Com o botão do lado direito sobre o item de menu Manage Books, selecionamos Events --> Action --> actionPerformed:

Isto provoca a geração de código na classe LibrarySystemView.java, associando um novo método ao evento de seleção do item de menu, e criando um template para esse novo método:

private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {                                           // TODO add your handling code here:}                    

2.2 Com o botão do lado direito sobre o item de menu Manage Books, selecionamosSet Action. Isto conduz-nos a uma janela para entrada de detalhes sobre o código que irá ser gerado:

Em Action, selecionamos Create New Action, e em Action's Method, escrevemos listBooks. O método listBooks() será criado de novo, e será associado ao evento de seleção do item de menu.

    @Action    public void listBooks() {    }

No método listBooks(), ou no jMenuItem1ActionPerformed() se optarmos pelo primeiro método, vamos colocar o código para troca de painéis.

@Actionpublic void listBooks() {    ListBooksJPanel listbooksP = new ListBooksJPanel(this, this.dbo);    this.visiblePanel.setVisible(false);    this.visiblePanel = listbooksP;    listbooksP.setVisible(true);    this.getFrame().setContentPane(listbooksP);    this.getFrame().repaint();    //}

Antes, tivémos que criar as variáveis de instância seguintes na classe LibrarySystemView:

private HelperDB.DBAccessObj dbo;private JPanel visiblePanel = null;

É também necessário criar código para ler os livros da base de dados e preencher a tabela no painel ListBooksJPanel. Para isso devem ser usadas as classes da biblioteca de classes criada no artigo anterior.Se tiverem dificuldades com o código ou quiserem as sources do exemplo, coloquem comentários a este post.