Tribo do C.I.

Só mais um blog de informática (só que não)

Criando uma ConnectionFactory java com Xml

dezembro 6th, 2012

A maioria das aplicações trabalha com persistência de dados, ou seja, é necessário Gravar, Recuperar, Alterar e Deletar dados em algum Banco de Dados. Para essas 4 operações básicas é usada a sigla CRUD (Create, Read, Update, Delete) e é necessário uma conexão com o banco de dados para realizá-las. Para isso, é sempre criada uma classe com método(s) de Fábrica de Conexão (Connection Factory) e o código para isso fica parecido com o código mostrado na imagem abaixo:

Connection Factory

Os dados necessários para uma conexão com o banco são:

  • Usuário;
  • Senha;
  • URL de conexão;
  • Banco de Dados;

Porém, no exemplo da imagem acima, essas configurações ficam amarradas ao código, sendo necessário reescrever a classe e recompilar o programa a cada vez que qualquer um desses dados é alterado. Então a melhor sugestão seria criar um arquivo de configuração externo ao programa que mantem esses dados. Para isso utilizaremos dos recursos das classes: java.util.Properties, java.io.FileInputStreamjava.io.FileOutputStream.

Primeiro, criaremos uma classe que cuidará dessa parte, podemos nomeá-la JdbcConnection:

public class JdbcConnection {
private String user;
private String passwd;
private String url;
private String database;
//Criar getters e setters
}

Como o arquivo de configuração ainda não existe, teremos que criar, dentro da classe JdbcConnection um método para criação do arquivo Xml utilizando um objeto Properties:

    public void setProps(){
        Properties props = new Properties();

        props.setProperty("jdbc.user", "postgres");
        props.setProperty("jdbc.passwd", "senha");
        props.setProperty("jdbc.url", "jdbc:postgresql://localhost:5433");
        props.setProperty("jdbc.dataBase","banco");

        try {
            FileOutputStream fos = new FileOutputStream("config.xml");
            props.storeToXML(fos, "FILE JDBC PROPERTIES:","ISO-8859-1");
            fos.close();

        }catch (IOException e){
            System.out.println(e.getMessage());
        }

    }

Assim, será criado um arquivo parecido com esse:

<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>FILE JDBC PROPERTIES:</comment>
<entry key="jdbc.passwd">error#404</entry>
<entry key="jdbc.url">jdbc:postgresql://localhost:5433</entry>
<entry key="jdbc.user">postgres</entry>
<entry key="jdbc.dataBase">ponto</entry>
</properties>

Através das informações contidas nesse arquivo, iremos preencher os atributos de um objeto JdbcConnection, e para isso criamos o método abaixo:

    public void getProps (){
        Properties props = new Properties();

        try {
            //Setamos o arquivo que será lido
            FileInputStream fis = new FileInputStream("config.xml");
            //método load faz a leitura através do objeto fis
            props.loadFromXML(fis);
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        //Captura o valor da propriedade, através do nome da propriedade(Key)
        this.setUser(props.getProperty("jdbc.user"));
        this.setPasswd(props.getProperty("jdbc.passwd"));
        this.setUrl(props.getProperty("jdbc.url"));
        this.setDatabase(props.getProperty("jdbc.dataBase"));

    }

E para finalizar, o nosso método de Conexão ficaria mais ou menos dessa forma:

    public static Connection getConnection(){
        Connection con = null;
        try {
            JdbcConnection jdbc = new JdbcConnection();
            jdbc.getProps();
            if (jdbc.getUrl() == null) {
                jdbc.setProps();
                jdbc.getProps();
            }

            con = (Connection) DriverManager.getConnection(jdbc.getUrl() + "/" + jdbc.getDatabase(), jdbc.getUser(), jdbc.getPasswd());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return con;
    }

Note que é preciso testar se o arquivo existe, para que os atributos do objeto jdbc não venham vazios. A maneira mais prática e didática que veio na minha mente foi testar se algum dos atributos ainda está nulo mesmo depois da chamada jdbc.getProps(); e, caso esteja nulo, chamo jdbc.setProps(); com as configurações “amarradas” no código-fonte do seu sistema. Porém, depois do arquivo gerado é possível alterar sem problemas.

Corpo humano definido em html+php

fevereiro 7th, 2011

Just For Fun

Linguagens formais e Autômatos – 3

dezembro 1st, 2010

Para ver a segunda parte clique aqui

Expressões regulares – Toda Linguagem Regular pode ser descrita por uma expressão simples denominada Expressão Regular. Trata-se de um formalismo denotacional também considerado gerador, pois pode-se inferir como construir (“gerar”) as palavras de uma linguagem. É uma maneira de representar uma linguagem formada pela justaposição dos símbolos do alfabeto separados pelos símbolos de união ou concatenação.

Linguagem – Conjunto de palavras

L1 = {0,01,11} ou L2 = {111,000}

Operações

L1UL2 = {0,01,11,111,000}

L1L2 = {0111,0000,0011,…}

L1*={0000,010101,…)

Linguagens Regulares – São aquelas que podem ser representadas por expressão regular ou autômatos.

Exemplos:

  • L=Cadeias que possuem apenas um 0 E={0,1}
    • 1*01*
  • L=Cadeias que possuem todas as strings binárias E={0,1}
    • (0U1)*
  • L=Cadeias que possuem todas as strings binárias exceto o vazio E={0,1}
    • (oU1)+
  • L=Cadeias que começam com aa e terminam com bb E={a,b}
    • aa(aUb)*bb
  • L=Cadeias que começam ou terminam com bb E={a,b}
    • bb(aUb)*U(aUb)*bb

Por definição, uma linguagem é Regular se, e somente se, é possivel construir um Autômato Finito (Determinístico, Não-Determinístico ou com Movimentos Vazios), que reconheça a linguagem.

Transformação de Autômato/ER

  1. Incluir dois estados ( um inicial, que aponta para o inicial antigo por E(movimento vazio), e um estado final, todos os finais antigos do autômato deixam de ser finais e apontam por E para o novo).
  2. Avaliar dois a dois os estados na tentativa de eliminar um terceiro.


Hierarquia de Chomsky

É a classificação de gramáticas formais descrita em 1959 pelo linguista Noam Chomsky. Esta classificação possui 4 níveis (Descritos na figura ao lado), sendo que os dois últimos níveis (os níveis 2 e 3) são amplamente utilizados na descrição de linguagem de programação e na implementação de interpretadores e compiladores. Mais especificamente, o nível 2 é utilizado em análise sintática (computação) e o nível 3 em análise léxica.

A classificação das gramáticas começa pelo tipo 0, com maior nível de liberdade em suas regras, e aumentam as restrições até o tipo 3. Cada nível é um super conjunto do próximo. Logo, uma gramática de tipo n é conseqüentemente uma linguagem de tipo n-1.

  • Linguagem tipo 3: Regular
    • Reconhecida por um autômato finito
    • Representada por uma expressão regular
  • Linguagem tipo 2: Livre de contexto
    • Reconhecida por um autômato de pilha
  • Linguagem tipo 1: sensível ao contexto
  • Linguagem tipo 0: Irrestrita
    • Máquina de Turing

Lema do Bombeamento

Diz que se pegarmos uma cadeia de tamanho maior do que a quantidade de estados do autômato, existe um pedaço dessa cadeia que pode ser bombeada (repetida em um looping) de forma que a cadeia gerada ainda pertence a linguagem.

Isso significa que existe um looping dentro do autômato. O lema do Bombeamento serve para provar que uma linguagem “NÃO” é regular. A demonstração de que uma linguagem é regular é feita através da criação de um autômato ou expressão regular.

Não é regular

-Afirme que é regular

-Escolha uma que você ache que não é regular

-Bombear

-Provar que não é regular.

O que foi descrito neste artigo é somente o começo dos estudos das linguagens formais. Foi dividido em 3 partes, é possível acessar a segunda parte clicando aqui, e a primeira parte clicando aqui. O artigo foi baseado no livro: Linguagens Formais e Autômatos, Série Livros Didáticos Segunda edição, de Paulo Fernando Blauth Menezes, com alguns pedaços de texto retirados da Wikipedia.


Expressões Regulares e suas respectivas linguagens

Expressão Regular

Linguagem Representada

aa

Somente a palavra aa

ba*

Todas as palavras que iniciam por b, seguido por zero ou mais a

(a+b)*

Todas as palavras sobre {a,b}

(a+b)*aa(a+b)*

Todas as palavras contendo aa como subpalavra

a*ba*ba*

Todas as palavras contend exatamente dois b

(a+b)*(aa+bb)

Todas as palavras que terminam com aa ou bb

(a+E)(b+ba)*

Todas as palavras que não possuem dois a consecutivos.

Tribo do C.I.

Tribo do C.I.

Só mais um blog de informática (só que não)