Considerando um conjunto de linhas de uma consulta, uma window function é capaz de realizar cálculos em uma linha com base em dados presentes em linhas relacionadas à esta (de mesmo valor, vizinhas, etc.). Nesse contexto, um grupo de linhas correlacionadas é considerada uma janela (“window”). Na própria consulta definimos qual serão as janelas para que uma função de agregação trabalhe sobre a mesma.

Esta funcionalidade pode ser considerada complementar às clássicas funções de agregação (SUM, COUNT, MIN, MAX, etc.), que estão comumente associadas à clausula GROUP BY, entretanto estas podem ser usadas também como window function. A principal diferença é que o uso de uma window function não faz com que o resultado seja agrupado em apenas uma linha, podendo este ser distribuído pelas linhas presentes originalmente na consulta. Isso possibilita alcançar resultados antes possíveis somente com linguagens procedurais ou subconsultas.

Vamos à prática

Para facilitar o entendimento, consideramos como exemplo um banco de dados que armazena a quantidade de acessos às páginas de uma empresa. De forma simplificada, o esquema da tabela poderia ser o seguinte:

CREATE TABLE paginas (
  dominio text not null, -- [Sub]domínio
  url text not null,     -- URL, dentro do [sub]domínio
  acessos integer,       -- quantidade de acessos
  tags text[],           -- array de tags
  CONSTRAINT pk_paginas PRIMARY KEY (dominio, url)
);

Inserindo alguns dados:

INSERT INTO paginas(dominio,url,acessos,tags)
VALUES
('www.example.com', '/index.html',        448, '{index,exemplo}'),
('www.example.com', '/contato.html',      201, '{contato}'),
('www.example.com', '/exemplo.html',      272, '{exemplo,teste}'),
('blog.example.com', '/index.html',       513, '{blog}'),
('blog.example.com', '/postgresql.html',  896, '{blog,postgresql}'),
('blog.example.com', '/postgres-xc.html', 1036, '{postgresql,escalabilidade}'),
('evento.example.com', '/',                640, '{evento,postgresql}'),
('evento.example.com', '/inscricao.html',  289, '{evento,inscrição}');

Usando uma clássica função de agregação e o GROUP BY

Verificar a quantidade média de acesso por domínio:

SELECT dominio, AVG(acessos) AS media_acessos
FROM paginas
GROUP BY dominio;

      dominio       |     media_acessos
--------------------+----------------------
 evento.example.com | 464.5000000000000000
 www.example.com    | 307.0000000000000000
 blog.example.com   | 815.0000000000000000

Basicamente, o PostgreSQL irá agrupar toda linha que possua a mesma categoria, como representado na figura:

Usando WINDOW FUNCTION

Definição de janela com o PARTITION BY

Tendo por base o exemplo anterior, como verificar, com uma única consulta, a comparação de acessos de cada URL com a média de acesso do domínio ao qual a mesma pertence?

SELECT dominio, url,
  AVG(acessos) OVER(PARTITION BY dominio) AS media_acessos
FROM paginas;

       dominio      |        url        |     media_acessos
--------------------+-------------------+----------------------
 www.example.com    | /contato.html     | 307.0000000000000000
 www.example.com    | /index.html       | 307.0000000000000000
 www.example.com    | /exemplo.html     | 307.0000000000000000
 blog.example.com   | /index.html       | 815.0000000000000000
 blog.example.com   | /postgres-xc.html | 815.0000000000000000
 blog.example.com   | /postgresql.html  | 815.0000000000000000
 evento.example.com | /inscricao.html   | 464.5000000000000000
 evento.example.com | /                 | 464.5000000000000000

A cláusula OVER referencia a janela que o PostgreSQL usará para realizar a agregação. A janela foi determinada usando o PARTITION BY, que, (de forma semelhante ao GROUP BY) agrupa as tuplas, fazendo com que todas do mesmo grupo, ou mesma partição, recebam o resultado da agregação. No nosso exemplo, consideramos o campo domínio como uma partição. A função AVG calcula a média para cada janela. Dessa forma, é possível manter as linhas originais apesar dos valores agregados, como mostra a figura:

Definição de janela com o ORDER BY

Ainda neste cenário, vamos substituir a coluna de média de acessos por ma coluna que mostre a soma parcial dos acessos. O resultado que buscamos é o seguinte:

      dominio       |        url        | acessos | parcial
--------------------+-------------------+---------+---------
 www.example.com    | /contato.html     |     201 |     201
 www.example.com    | /exemplo.html     |     272 |     473
 evento.example.com | /inscricao.html   |     289 |     762
 www.example.com    | /index.html       |     448 |    1210
 blog.example.com   | /index.html       |     513 |    1723
 evento.example.com | /                 |     640 |    2363
 blog.example.com   | /postgresql.html  |     896 |    3259
 blog.example.com   | /postgres-xc.html |    1036 |    4295

Para tanto, podemos definir nossa janela utilizando a cláusula ORDER BY:

SELECT dominio, url, acessos,
SUM(acessos) OVER(ORDER BY acessos, dominio, url) AS parcial
FROM paginas
ORDER BY acessos, dominio, url;

Quando definimos uma janela com o ORDER BY, o resultado é calculado primeiro ordenando as linhas, e, em seguida, calculando a agregação de forma incremental, linha a linha. A figura abaixo representa essa operação:

E se quisermos a soma parcial e a média, ambas agrupados por domínio? Da seguinte forma:

      dominio       |        url        | acessos | media_acessos | parcial
--------------------+-------------------+---------+---------------+---------
 blog.example.com   | /index.html       |     513 |         815.0 |     513
 blog.example.com   | /postgresql.html  |     896 |         815.0 |    1409
 blog.example.com   | /postgres-xc.html |    1036 |         815.0 |    2445
 evento.example.com | /inscricao.html   |     289 |         464.5 |     289
 evento.example.com | /                 |     640 |         464.5 |     929
 www.example.com    | /contato.html     |     201 |         307.0 |     201
 www.example.com    | /exemplo.html     |     272 |         307.0 |     473
 www.example.com    | /index.html       |     448 |         307.0 |     921

Além de manter a função AVG com a definição PARTITION BY, a função SUM é calculada sobre janelas definidas ao mesmo tempo por PARTITION BY e ORDER BY, como segue:

SELECT dominio, url, acessos,
  AVG(acessos) OVER(PARTITION BY dominio) AS media_acessos,
  SUM(acessos) OVER(PARTITION BY dominio ORDER BY acessos, url) AS parcial
FROM paginas
ORDER BY dominio, acessos, url;

Outras funções de agregação

Como mostrado nos exemplos acima, qualquer função de agregação já conhecida pode ser usado como uma window function, entretanto o PostgreSQL também oferece 11 funções específicas desta funcionalidade.

Por exemplo, usando a função row_number podemos adicionar um número sequencial em cada uma das linhas:

SELECT row_number() OVER(ORDER BY dominio, acessos, url),
  dominio, url, acessos,
  SUM(acessos) OVER(PARTITION BY dominio ORDER BY acessos, url) AS parcial
FROM paginas
ORDER BY dominio, acessos, url;

 row_number |      dominio       |        url        | acessos | parcial
------------+--------------------+-------------------+---------+---------
          1 | blog.example.com   | /index.html       |     513 |     513
          2 | blog.example.com   | /postgresql.html  |     896 |    1409
          3 | blog.example.com   | /postgres-xc.html |    1036 |    2445
          4 | evento.example.com | /inscricao.html   |     289 |     289
          5 | evento.example.com | /                 |     640 |     929
          6 | www.example.com    | /contato.html     |     201 |     201
          7 | www.example.com    | /exemplo.html     |     272 |     473
          8 | www.example.com    | /index.html       |     448 |     921

É possível fazer isto também por partições:

SELECT row_number() OVER(PARTITION BY dominio ORDER BY acessos, url),
dominio, url, acessos,
SUM(acessos) OVER(PARTITION BY dominio ORDER BY acessos, url) AS parcial
FROM paginas
ORDER BY dominio, acessos, url;

 row_number |      dominio       |        url        | acessos | parcial
------------+--------------------+-------------------+---------+---------
          1 | blog.example.com   | /index.html       |     513 |     513
          2 | blog.example.com   | /postgresql.html  |     896 |    1409
          3 | blog.example.com   | /postgres-xc.html |    1036 |    2445
          1 | evento.example.com | /inscricao.html   |     289 |     289
          2 | evento.example.com | /                 |     640 |     929
          1 | www.example.com    | /contato.html     |     201 |     201
          2 | www.example.com    | /exemplo.html     |     272 |     473
          3 | www.example.com    | /index.html       |     448 |     921

Conclusão

WINDOW FUNCTION é um recurso muito útil, principalmente para consultas a serem usadas em relatórios analíticos. Vale destacar que o PostgreSQL, até a escrita desse artigo, é o único banco de dados open-source a implementar esta funcionalidade, o que mostra, mais uma vez, que o elefante possui funcionalidades equiparáveis à bancos de dados comerciais.

Em breve, lançaremos aqui uma continuação desse artigo, mostrando exemplos com todas as 11 funções de janela presentes nativamente no PostgreSQL.

Aguarde.

Replicação em cascata

Talvez essa seja a funcionalidade mais esperada do PostgreSQL 9.2: a possibilidade de realizar replicação em cascata.

As melhorias no gerenciamento de log de transações para servidores slaves de uma replicação, torna possível a execução de processos “wal sender” nestes servidores, permitindo que um servidor slave se conecte à outro servidor slave para realizar a replicação em cascata.

A replicação em cascata é especialmente útil para sistemas distribuídos, conseguindo fazer com que cada servidor slave seja sincronizado a partir de outro servidor mais próximo, seja este um slave ou master. Além disso, a distribuição da replicação faz com que o uso de recursos seja reduzido no servidor master.

Além da replicação em cascata, a nova versão traz a possibilidade de realização de backup incremental a partir de um servidor slave. Com isso, ganha-se tanto em distribuição de tarefas quanto em segurança, podendo realizar o mesmo backup em vários pontos distintos.

Novos tipos de dados

Três novos tipos de dados nativos foram incluídos na nova versão do PostgreSQL.

Depois do sucesso da inclusão do tipo de dados XML na versão 8.3 do PostgreSQL, agora é possível armazenar tipo de dados JSON. É claro que o conteúdo do JSON já podia ser armazenado num campo tipo text, entretanto o tipo de dados específico para JSON é capaz de validar e auxiliar no processamento desse tipo de informação.

Vários tipos de dados para representação de intervalos foram adicionados. Estes tipos de dados são capazes de adicionar valor inicial e final de um intervalo, podendo este intervalo ser: inteiro, decimal, data/hora ou data. Além disso, novos tipos de dados de intervalo podem ser criados com o comando CREATE TYPE.

Além da representação, vários operadores e funções foram definidos para realizar o processamento desses tipos de dados de forma mais ágil. Outro ponto importante é a possibilidade de indexação desses dados com índices GiST e a criação de restrições (“constraints”) para estes dados.

Index-only scans

Nas versões anteriores do PostgreSQL, os índices eram usados apenas como referência para a tabela, ou seja, para recuperar o valor buscado, sempre era necessária a busca do registro na tabela após a varredura do índice.

Com a funcionalidade de “index-only scans” ou “varreduras apenas em índice”, o PostgreSQL não precisa mais buscar o valor de um campo na tabela, agora ele é capaz de buscar esse valor diretamente no índice. No caso de um SELECT executado numa tabela que contém um índice com todos os campos que serão retornados (em qualquer parte da cláusula), o PostgreSQL não precisará mais buscar na tabela para devolver o resultado, este será capaz de retornar o resultado com o valor presente no índice.

Exemplo:

Criação de uma tabela para teste:

postgres=# CREATE TABLE teste AS
SELECT id, md5(random()::text) AS valor1, md5(random()::text) AS valor2
FROM generate_series(1, 100000) AS id;
SELECT 100000
Time: 2639.959 ms

Criação de um índice com o campo id e valor1:

postgres=# CREATE INDEX idx_teste ON teste (id, valor1);
CREATE INDEX
Time: 1336.790 ms

Busca pelo id = 90000 e retornando todos os campos:

postgres=# EXPLAIN ANALYZE SELECT id, 

valor1, valor2 FROM teste WHERE id = 90000;
               QUERY PLAN
-----------------------------------------------------------------------
 Index Scan using idx_teste on teste  (cost=0.00..8.56 rows=1 width=70)

(actual time=29.077..29.081 rows=1 loops=1)

   Index Cond: (id = 90000)
 Total runtime: 29.165 ms
(3 rows)

Time: 239.084 ms

O “Index Scan”, usado acima pelo PostgreSQL, é capaz de filtrar os registros pelo índice, mas deve buscar o valor na tabela.

Agora, buscando também pelo id = 90000, mas sem retornar o campo valor2 (que não está indexado):

postgres=# EXPLAIN ANALYZE SELECT id, valor1 FROM teste WHERE id = 90000;
                                                      QUERY PLAN
----------------------------------------------------------------------------
 Index Only Scan using idx_teste on teste  (cost=0.00..8.56 rows=1 width=37)

(actual time=8.331..8.335 rows=1 loops=1)

   Index Cond: (id = 90000)
   Heap Fetches: 1
 Total runtime: 8.419 ms
(4 rows)

Time: 68.973 ms

Nesta consulta o otimizador do PostgreSQL decidiu usar a nova funcionalidade, o “Index Only Scan”, para evitar a busca dos dados na tabela.

Novo utilitário: “pg_receivexlog”

O backup incremental é uma funcionalidade presente no PostgreSQL desde a versão 8.0. Esta forma de backup permite o arquivamento de logs de transação logo após um processo de CHECKPOINT. A grande vantagem dessa funcionalidade é que a mesma permite o uso da técnica de PITR (Point-In-Time Recovery), que torna possível restaurar o estado exato do servidor PostgreSQL em qualquer ponto no tempo. Para que isso aconteça, um backup base (backup dos arquivos físicos) é necessário, e o arquivamento dos logs de transação (Write-ahead-logs) a partir deste backup base.

O backup incremental acontece após o CHECKPOINT, que por sua vez aguarda o preenchimento dos arquivos de log de transação (checkpoint_segments) ou um timeout (checkpoint_timeout). Dessa forma, o backup permanece em atraso equivalente a algumas transações.

Com a versão 9.0 do PostgreSQL surgiu o conceito de replicação por fluxo de dados (streaming replication). Na 9.2, essa técnica pode ser utilizada não somente para replicação, mas também para execução do backup incremental. A ferramenta pg_receivexlog passa a fazer parte do conjunto de ferramentas administrativas do PostgreSQL, para permitir o uso do protocolo de replicação por fluxo de dados na estratégia de backup, garantindo um backup fiel ao ambiente de produção.

Melhorias na contrib “pg_stat_statements”

A extensão “pg_stat_statements”, presente desde a versão 8.4 do PostgreSQL, possui uma funcionalidade de grande utilidade. Esta extensão é capaz de capturar os comandos mais lentos e mais executados no banco de dados. A grande vantagem desta extensão, se comparada à interpretadores de log de atividades, como o pgFouine, é o fato da mesma conseguir os resultados sempre em tempo real, por ser uma biblioteca carregada pelo servidor do PostgreSQL e apresentar os resultados na view pg_stat_statements.

Entretanto, esta não era uma extensão muito adotada, pelo fato de considerar os comandos SQL com as constantes, não agregando comandos semelhantes. Ou seja, as consultas abaixo eram consideradas diferentes para a pg_stat_statements:

SELECT * FROM teste WHERE valor2 LIKE 'a%';
SELECT * FROM teste WHERE valor2 LIKE 'b%';

A versão dessa extensão para o PostgreSQL 9.2, passa a ignorar as constantes, tratando as consultas acimas como equivalentes por considerar apenas a estrutura do comando. O valor apresentado na view pg_stat_statements para a consulta acima é o seguinte:

SELECT * FROM teste WHERE valor2 LIKE ?;

Background Checkpointer

O PostgreSQL é um sistema multi-processo, o que significa que vários processos são usados para o gerenciamento do banco de dados e conexões. Para cada conexão de usuário um processo filho é criado para gerenciar a mesma, e além disso, também são criados processos filhos para a execução de tarefas administrativas, como o “autovacuum launcher”, responsável por iniciar processos (novos filhos) automáticos de VACUUM.

No Linux, uma forma simples de encontrar todos os processos do PostgreSQL sendo executados é com o utilitário “ps”, filtrando pelos processos que são executados pelo usuário “postgres” (no caso de uma instalação padrão do PostgreSQL):

$ ps f -u postgres
  PID TTY    STAT    TIME COMMAND
 2878 ?      S      53:51 /usr/local/pgsql9.2/bin/postgres -D /usr/local/pgsql9.2/data/
 3079 ?      Ss      9:10  \_ postgres: logger process
 3174 ?      Ss     37:28  \_ postgres: writer process
 3175 ?      Ss     27:13  \_ postgres: checkpointer process
 3176 ?      Ss     27:13  \_ postgres: wal writer process
 3177 ?      Ss    573:38  \_ postgres: autovacuum launcher process
 3178 ?      Ss      5:50  \_ postgres: archiver process   last was 000000010000000100000073
 3179 ?      Ss   1578:05  \_ postgres: stats collector process
14359 ?      Ss      0:00  \_ postgres: postgres postgres 172.16.129.122(34176) idle
14387 ?      Ss      0:00  \_ postgres: postgres postgres 172.16.129.122(34184) idle
14395 ?      Ss      0:00  \_ postgres: postgres postgres 172.16.129.122(34190) idle

Um outro processo administrativo, presente desde a versão 8.0, é o “writer” ou também conhecido como “background writer”. Este é um processo essencial para o PostgreSQL, e, até a versão 9.1 era responsável pela realização de duas tarefas:

• Escrita de páginas sujas no buffer de memória para o disco;
• Execução do processo de CHECKPOINT.

A partir da versão 9.2 do PostgreSQL, o “background writer” foi divido em dois processos, passando agora a ser responsável apenas pela escrita de páginas sujas em disco. Essa divisão criou um novo processo filho, o “background checkpointer”, agora responsável pela execução do CHECKPOINT.

Com essa divisão, espera-se melhorar a distribuição nas operações de escrita. Com isso, pode-se esperar também um ganho em desempenho, principalmente em sistemas com uso intensivo de entrada/saída (I/O bound).

Melhor escalabilidade vertical

Na versão 9.2 algumas mudanças no código-fonte do PostgreSQL trouxeram grandes melhorias de desempenho, aprimorando ainda mais a escalabilidade vertical. Esta melhoria no PostgreSQL aliado à algumas atualizações no kernel 3.2 do Linux tornou esse ganho muito expressivo nessa versão. Testes comparando a escalabilidade do PostgreSQL 9.1 e 9.2 comprovaram que um grande ganho em servidores com processadores multi-núcleos de 32 e 64 núcleos.

Pra matar aquela ansiedade que ficou no post anterior… e que ansiedade que eu causei em… quase duas semanas… desculpa pessoal pelo atraso.

Assunto

• Serialização e Herança

Serialização e Herança

Regras

1. Se a superclasse for Serializable, todas as subclasses também serão.

2. Se a classe filha for Serializable, a classe pai não precisa ser obrigatoriamente Serializable.

3. Se a classe filha for Serializable e a classe pai não for, na classe pai as variáveis serão inicializadas e o construtor será chamado.

Veja um exemplo abaixo:

public class ManipulandoSerializacaoComHeranca {

public static void main(String[] args) {

Moto moto = new Moto(“Susuki”, 240d);

try {

System.out.println(“Antes – Moto: “ + moto.getMarca() + “, “ + moto.getVelocidadeMaxima() + “, ” + moto.getQuantidadeRoda());

FileOutputStream fos = new FileOutputStream(“arquivo.txt”);

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(moto);

oos.close();

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

try {

FileInputStream fis = new FileInputStream(“arquivo.txt”);

ObjectInputStream ois = new ObjectInputStream(fis);

moto = (Moto) ois.readObject();

ois.close();

System.out.println(“Depois – Moto: “ + moto.getMarca() + “, ” + moto.getVelocidadeMaxima() + “, “ + moto.getQuantidadeRoda());

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

}

}

public class Automovel {

protected Double velocidadeMaxima;

protected Integer quantidadeRoda = 4;

public Automovel() {

System.out.println(“Acesso ao construtor Automovel”);

velocidadeMaxima = 60d;

}

public Double getVelocidadeMaxima() { return velocidadeMaxima; }

public Integer getQuantidadeRoda() { return quantidadeRoda; }

}

public class Moto extends Automovel implements Serializable {

private static final long serialVersionUID = -5169128571918185183L;

private String marca;

public Moto(String marca, Double velocidadeMaxima) {

this.quantidadeRoda = 2;

this.marca = marca;

this.velocidadeMaxima = velocidadeMaxima;

}

public String getMarca() { return marca; }

}

Console:

Acesso ao construtor Automovel // new Moto()

Antes – Moto: Susuki, 240.0, 2

Acesso ao construtor Automovel // ois.readObject()

Depois – Moto: Susuki, 60.0, 4 // seta os valores default

…

Altere a classe Automovel para “implements Serializable” e veja o resultado:

Console:

Acesso ao construtor Automovel

Antes – Moto: Susuki, 240.0, 2

Depois – Moto: Susuki, 240.0, 2

Repare que o construtor Automovel não foi chamado na execução “ois.readObject()” e os valores foram mantidos.

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje vamos ver Serialização que é bem utilizado na nossa realidade de desenvolvimento de projetos.

O que iremos ver será especificamente para a Certificação, não estenderei o conteúdo… Mas sintam-se à vontade para perguntar sobre o assunto.

O que é Serialização?

Serialização é guardar o estado de um objeto em bytes seja em disco ou em um stream.

Classes e métodos importantes

1. FileInputStream – Utilizada para ler bytes e transformar em objetos.

2. FileOutputStream – Utilizada para escrever objetos em bytes e guardar no disco.

3. ObjectInputStream - Classe de nível mais alto, ou seja, classe de encapsulamento. Nesse caso encapsula a classe FileInputStream.

3.1. readObject – método responsável por ler bytes e transformar em objeto.

3.2. defaultReadObject – inicia processo de deserialização.

3.3. readInt – retornar um valor int da deserialização.

4. ObjectOutputStream – Classe de nível mais alto, ou seja classe de encapsulamento. Nesse caso encapsula a classe FileOutputStream.

4.1. writeObject – método responsável por transformar o objeto em bytes no disco.

4.2. defaultWriteObject – inicia processo de serialização.

4.3. writeInt – escreve um valor int na serialização.

5. Serializable – Interface que indica se uma classe é serializável.

Considerações

1. Na deserialização não é chamado o construtor da classe do objeto deserializado, MAS quando houver herança teremos um comportamento diferente (fica para o próximo post para lhes deixarem curiosos =D).

Como serializar um objeto?

Vamos ver um exemplo bem simples :

public class ManipulandoSerializacaoSimples {

public static void main(String[] args) {

Pessoa pessoa = new Pessoa(“Dextrino”, new Endereco(“Campinas”, “SP”, “Brasil”));

try {

System.out.println(“Antes – Pessoa: “ + pessoa.getNome() + “, “ + pessoa.getEndereco().getEnderecoCompleto());

FileOutputStream fos = new FileOutputStream(“arquivo.txt”);

ObjectOutputStream oos = new ObjectOutputStream(fos);

// Escreve o objeto pessoa no arquivo.txt

oos.writeObject(pessoa);

oos.close();

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

try {

FileInputStream fis = new FileInputStream(“arquivo.txt”);

ObjectInputStream ois = new ObjectInputStream(fis);

// Le o arquivo.txt e referencia o objeto pessoa

pessoa = (Pessoa) ois.readObject();

ois.close();

// Repare que a classe Endereco implementa Serializable, portanto o atributo endereco foi serializado e deserializado

System.out.println(“Depois – Pessoa: “ + pessoa.getNome() + “, “ + pessoa.getEndereco().getEnderecoCompleto());

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

}

}

public class Pessoa implements Serializable {

private static final long serialVersionUID = 619337379561831879L;

private String nome;

private Endereco endereco;

public Pessoa(String nome, Endereco endereco) {

this.nome = nome;

this.endereco = endereco;

}

public String getNome() { return nome; }

public Endereco getEndereco() { return endereco; }

}

public class Endereco implements Serializable {

private static final long serialVersionUID = -9092198905086132027L;

private String cidade, estado, pais;

public Endereco(String cidade, String estado, String pais) {

this.cidade = cidade;

this.estado = estado;

this.pais = pais;

}

public String getCidade() { return cidade; }

public String getEstado() { return estado; }

public String getPais() { return pais; }

public String getEnderecoCompleto() { return cidade + “-” + estado + “, “ + pais; }

}

Considerações

1. Se a classe Endereco não fosse Serializable ocorreria a seguinte exceção:

java.io.NotSerializableException: br.com.certificacao.Endereco

Mas e se apenas quiséssemos que um atributo de endereço fosse serializado?

Utilizaríamos a palavra-chave transiente e reimplementaríamos os métodos writeObject e readObject.

Vejamos um exemplo com Produto e Embalagem.

public class ManipulandoSerializacaoComTransiente {

public static void main(String[] args) {

Produto produto = new Produto(“Dextrino”, new Embalagem(“Caixa com 10 unidades”, 10));

try {

System.out.println(“Antes – Produto: “ + produto.getNome() + “, “ + produto.getEmbalagem().getQuantidade());

FileOutputStream fos = new FileOutputStream(“arquivo.txt”);

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(produto);

oos.close();

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

try {

FileInputStream fis = new FileInputStream(“arquivo.txt”);

ObjectInputStream ois = new ObjectInputStream(fis);

produto = (Produto) ois.readObject();

ois.close();

System.out.println(“Depois – Produto: “ + produto.getNome() + “, “ + produto.getEmbalagem().getQuantidade());

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

}

}

public class Produto implements Serializable {

private static final long serialVersionUID = 8973295619843486332L;

private String nome;

private transient Embalagem embalagem;

public Produto(String nome, Embalagem embalagem) {

this.nome = nome;

this.embalagem = embalagem;

}

public String getNome() { return nome; }

public Embalagem getEmbalagem() { return embalagem; }

// SO serializamos o atributo quantidade do atributo endereco

private void writeObject(ObjectOutputStream oos) {

try {

oos.defaultWriteObject();

oos.writeInt(embalagem.getQuantidade());

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

}

// SO deserializamos o atributo quantidade do atributo endereco

private void readObject(ObjectInputStream ois) {

try {

ois.defaultReadObject();

embalagem = new Embalagem(null, ois.readInt());

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

}

}

public class Embalagem {

private String descricao;

private Integer quantidade;

public Embalagem(String descricao, Integer quantidade) {

this.descricao = descricao;

this.quantidade = quantidade;

}

public String getDescricao() { return descricao; }

public Integer getQuantidade() { return quantidade; }

}

No próximo post iremos ver Serialização com herança e suas pegadinhas… até mais.

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje vamos falar um pouco sobre o pacote java.io. Um pacote que nos fornece possibilidades de trabalhar com entrada e saída de dados e serialização. Mas hoje iremos trabalhar apenas com manipulação de arquivos e diretórios, lembrando que nosso conceito é focado na certificação.

Assuntos

• Manipulando arquivos
• Manipulando diretórios

Classes que estudaremos para a Certificação

• File – Essa classe é uma representação abstrata de nomes de arquivos e diretórios.
• FileReader – Essa classe é responsável para ler arquivos de caracteres.
• BufferedReader – Essa classe é usada para tornar classes Reader como FileReader fáceis de serem usadas.
• FileWriter – Essa classe é usada para escrever em arquivos de caracteres.
• BufferedWriter – Essa classe é usada para tornar classes Writer como FileWriter fáceis de serem usadas.
• PrintWriter – Essa classe é usada para tornar classes Writer como FileWriter fáceis de serem usadas.

Estudaremos essas classes na prática… (veja as dicas no final)

1. Manipulando Arquivos

1.1. File

public static void main(String[] args) {

// Da o nome a um arquivo

File file001 = new File(“teste-001.txt”);

criacaoDeArquivoComFile(file001);

}

private static void criacaoDeArquivoComFile(File file) {

try {

// Verifica se existe o arquivo

System.out.println(file.exists());

// Cria o arquivo teste.txt caso nao exista

file.createNewFile();

// Verifica se existe o arquivo

System.out.println(file.exists());

} catch (IOException e) {

e.printStackTrace();

}

}

1.2. FileWriter e FileReader

public static void main(String[] args) {

File file002 = new File(“teste-002.txt”); // Da o nome a um arquivo

utilizandoWrapperFileWriter(file002);

utilizandoWrapperFileReader(file002);

}

private static void utilizandoWrapperFileWriter(File file) {

try {

// Cria o arquivo teste.txt

FileWriter fw = new FileWriter(file);

// escreve no arquivo

fw.write(“primeira frase FileWriter\nsegunda frase FileWriter”);

// garante que a ultima parte (buffer) foi entregue ao arquivo

fw.flush();

// libera recursos do S.O. utilizado

fw.close();

} catch (IOException e) {

e.printStackTrace();

}

}

private static void utilizandoWrapperFileReader(File file) {

try {

char[] entrada = new char[50];

// obtem o arquivo teste-002.txt

FileReader fr = new FileReader(file);

// Le a quantidade de bytes que tem o arquivo e dissolve cada caracter no array

int quantidadeDeBytes = fr.read(entrada);

System.out.println(“Quantidade de bytes: “ + quantidadeDeBytes);

for (char c : entrada) {

System.out.print(c);

}

// libera recursos do S.O. utilizado

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

}

1.3. PrintWriter, FileReader e BufferedReader

public static void main(String[] args) {

// Da o nome a um arquivo

File file003 = new File(“teste-003.txt”);

utilizandoWrapperPrintWriter(file003);

utilizandoWrapperBufferedReader(file003);

}

private static void utilizandoWrapperPrintWriter(File file) {

try {

// Cria o arquivo teste.txt

PrintWriter pw = new PrintWriter(file);

// escreve no arquivo

pw.println(“primeira frase PrintWriter”);

// escreve no arquivo

pw.println(“segunda frase PrintWriter”);

// garante que a ultima parte (buffer) foi entregue ao arquivo

pw.flush();

// libera recursos do S.O. utilizado

pw.close();

} catch (IOException e) {

e.printStackTrace();

}

}

private static void utilizandoWrapperBufferedReader(File file) {

try {

// obtem o arquivo teste-003.txt

FileReader fr = new FileReader(file);

// cria um buffer para obter os dados a partir do FileReader

BufferedReader br = new BufferedReader(fr);

String linha;

// enquanto houver uma linha com conteudo

while ((linha = br.readLine()) != null) {

System.out.println(linha);

}

// libera recursos do S.O. utilizado

br.close();

} catch (IOException e) {

e.printStackTrace();

}

}

2. Manipulando Diretórios

Como criar, renomear e deletar um diretório…

public static void main(String[] args) {

criandoUmDiretorioEAdicionandoUmArquivo();

}

private static void criandoUmDiretorioEAdicionandoUmArquivo(){

try {

File diretorio = new File(“novoDiretorio”);

// cria o diretorio

diretorio.mkdir();

// cria o arquivo no novoDiretorio

File novoArquivo = new File(diretorio, “arquivoNovo.txt”);

novoArquivo.createNewFile();

// retorna false – nao eh possivel deletar um diretorio que nao esteja vazio

System.out.println(diretorio.delete());

// renomeando diretorio

diretorio.renameTo(new File(“diretorioRenomeado”));

} catch (IOException e) {

e.printStackTrace();

}

}

Dicas

1. O construtor new File(“arquivo.txt”) não cria o arquivo no disco. Só será criado o arquivo ao invocar o método createNewFile().

2. O método renameTo() recebe um File.

3. Apenas as classes File, FileWriter e PrintWriter recebem uma String no construtor.

É isso ai pessoal, nos próximos posts vamos ver um pouco mais sobre o pacote java.io.

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje vamos falar um pouco sobre uma das classes mais utilizadas no nosso dia-dia, a classe String. E complementaremos com duas classes que são utilizadas para facilitar o uso das Strings.

Assuntos

• String
• StringBuffer e StringBuilder

String

O que precisamos saber de String para a certificação?

1. String é imutável, ou seja, uma vez atribuido um valor a uma String esse valor nunca poderá ser alterado.
2. Ao criar uma nova String a JVM verifica no pool de String se já existe alguma igual e então faz com que sua nova String (variável de referência) aponte para o Objeto (memória) existente.
3. Métodos:

charAt(); Retorna o caracter localizado no índice específico.

concat(); Anexa uma String ao final de outra.

equalsIgnoreCase(); Determina a igualdade de duas Strings, ignorando maiúsculas com minúsculas.

lenght(); Retorna o número de caracteres de uma String.

replace(); Substitui as ocorrências de um caracter por um outro caracter.

substring(); Retorna uma parte de uma String.

toLowerCase(); Retorna uma String em letras minúsculas.

toString(); Retorna o valor de uma String.

toUpperCase(); Retorna uma String em letras maiúsculas.

trim(); Remove os espaços em branco no início e no fim de uma String.

Vejamos alguns exemplos:

1. Métodos:

public static void main(String[] args) {

String s1 = “abcdef”;

System.out.println(s1);

char c = s1.charAt(3);

System.out.println(c);

s1 = s1.concat(“ghij”);

System.out.println(s1);

boolean equals = s1.equalsIgnoreCase(“ABCDEFGHIJ”);

System.out.println(equals);

int length = s1.length();

System.out.println(length);

String s2 = “XEGAX”.replace(‘X’, ‘L’);

System.out.println(s2);

System.out.println(s2.substring(2));

System.out.println(s2.substring(2, 4));

String s3 = “Java InTerEssAnte!”.toLowerCase();

System.out.println(s3);

String s4 = “Java InTerEssAnte!”.toUpperCase();

System.out.println(s4);

String s5 = ” 0123 456 “.trim();

System.out.println(s5);

}

2. String e a criação de Objetos

public static void main(String[] args) {

String a = “abcde”; // Cria 1º Objeto na memoria “abcde”

a.concat(“fghij”); // Cria o 2º “fghij” e o 3º “abcdefghij” Objeto na memoria

String b = “abcde”; // Nao cria um novo Objeto porque ja existe um Objeto “abcde” na memoria

}

3. Dica sobre concatenação com Strings

public static void main(String[] args) {

String a = “abcde”;

a = a + “fghij”; // O operador + adiciona a string posterior a string anterior “abcdefghij”

a.concat(“XX”); // Apenas a chamada ao metodo concat nao atribui o valor XX na variavel a

System.out.println(a);

a += “XX”; // Neste caso temos uma atribuicao, entao a variavel a recebera XX -> “abcdefghijXX”

System.out.println(a);

}

StringBuffer e StringBuilder

O que precisamos saber de StringBuffer e StringBuilder para a certificação?

1. São utilizadas para minimizar o pool de Strings caso você precise manipular várias de suas caracteres. Como vimos anteriormente cada String é um objeto em memória.
2. O StringBuffer pode ser manipulado repetidamente e não deixará Objetos Strings para trás.
3. A diferença:

A classe StringBuffer tem seus métodos declarados como synchronized e por isso são ótimos para trabalhar com Threads, já a classe StringBuilder não tem seus métodos sincronizados com isso tem a vantagem de que pode ser mais rápida (mas não use essa classe para sistemas com muitas threads).

Iremos trabalhar mais com essas classes quando falaremos de Threads.

Veja um exemplo de StringBuffer

public static void main(String[] args) {

StringBuffer s1 = new StringBuffer(“abcde”);

s1.append(“fghij”);

System.out.println(s1);

StringBuffer s2 = new StringBuffer(“abcde”);

s2.reverse().append(“fghij”).insert(5, “<>”);

System.out.println(s2);

}

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje nosso simulado é sobre Controle de fluxo, exceções e assertivas. Bons estudos!

1. Dado o código a seguir:

try { int x = Integer.parseInt(“dois”); }

Qual opção poderia ser usada para se criar um bloco catch apropriado? (marque todas as corretas)

A. ClassCastException

B. IllegalStateException

C. NumberFormatException

D. IllegalArgumentException

E. ExceptionInInitializerError

F. ArrayIndexOutOfBoundException

2. Dado o código a seguir:

public class Loop {

public static void main(String[] args) {

int[] x = {7,6,4,3,2,1};

// insira codigo aqui

System.out.println();

}

}

}

Qual opção, inserida independentemente na linha 4, compila? (marque todas as respostas corretas)

A. for (int y : x) {

B. for (x : int y) {

C. int y = 0; for(y : x) {

D. for (int y=0, z=0;  z<x.length;  z++) { y = x[z];

E. for (int y=0, int z=0;  z<x.length;  z++) { y = x[z];

F. int y = 0; for (int z=0;  z<x.length;  z++) { y = x[z];

3. Dado o código a seguir:

3. class SubException extends Exception {}

4. class SubSubException extends SubException {}

5.

6. public class Classe1 { void fazAlgumaCoisa() throws SubException {} }

7.

8. class Classe2 extends Classe1 { void fazAlgumaCoisa() throws SubSubException {} }

9.

10. class Classe3 extends Classe1 { void fazAlgumaCoisa() throws Exception {} }

11.

12. class Classe4 extends Classe1 { void fazAlgumaCoisa(int x) throws Exception {} }

13.

14. class Classe5 extends Classe1 { void fazAlgumaCoisa(){} }

Qual é o resultado? (marque todas as respostas corretas)

A. A compilação é bem-sucedida.

B. Ocorre falha na compilação devido a um erro na linha 8.

C. Ocorre falha na compilação devido a um erro na linha 10.

D. Ocorre falha na compilação devido a um erro na linha 12.

E. Ocorre falha na compilação devido a um erro na linha 14.

4. Dado o código a seguir:

public class Loop {

public static void main(String[] args) {

int [] ia = {1,3,5,7,9};

for (int x : ia) {

for (int j = 0; j < 3; j++){

if (x > 4 && x < 8 /**/) continue;

System.out.print(” “ + x);

if (j == 1) break;

continue;

}

continue;

}

}

}

Qual é o resultado?

A. 1 3 9

B. 5 5 7 7

C. 1 3 3 9 9

D. 1 1 3 3 9 9

E. 1 1 1 3 3 3 9 9 9

F. Ocorre falha na compilação

5. Dado o código a seguir:

public class Loop {

public static void main(String[] args) {

foreach : for (int j=0; j<5; j++) {

for (int k=0; k<3; k++) {

System.out.print(” ” + j);

if (j==3 && k==1) break foreach;

if (j==0 || j==2) break;

}

}

}

}

Qual é o resultado?

A. 0 1 2 3

B. 1 1 1 3 3

C. 0 1 1 1 2 3 3

D. 1 1 1 3 3 4 4 4

E. 0 1 1 1 2 3 3 4 4 4

F. Ocorre falha na compilação

6. Dado o código a seguir:

public class ManipulandoAssertivas {

public static void main(String[] args) {

int var = 1;

assert (++var > 1); // linha 4

assert (var++ > 2) : “algo”; // linha 5

assert (var > 4) : var = 12; // linha 6

assert (var == 6) : fazAlgumaCoisaComRetorno(); // linha 7

assert (var == 6) : fazAlgumaCoisaSemRetorno(); // linha 8

assert (var == 6) : new ManipulandoAssertivas(); // linha 9

}

static void fazAlgumaCoisaSemRetorno() { }

static String fazAlgumaCoisaComRetorno() { return “XX”; }

}

Qual é o resultado?

A. Ocorre múltiplas falhas de compilação.

B. Ocorre falha de compilação na linha 4.

C. Ocorre falha de compilação na linha 7.

D. Ocorre falha de compilação na linha 8.

E. Ocorre falha de compilação na linha 9.

F. O código compila com sucesso.

Hoje vamos falar um pouco sobre assertivas, um assunto que irá ter poucas questões na prova e que podem ajudar na pontuação.

Assuntos

• Assertivas

Assertivas

As assertivas são utilizadas para minimizar a quantidade de manipuladores de exceções que nunca vão ocorrer. Vamos ver um exemplo para entender melhor.

if (num >= 0) {

// faz alguma coisa

} else {

System.out.print(“Numero negativo: ” + num);

}

Já que você está tão certo que a variável num sempre será positiva então minimize seu código:

assert(num >= 0);

// faz alguma coisa

Sempre assuma que a condição (num >= 0) será verdadeira, caso contrário será lançada um AssertionError, e como vimos anteriormente, não podemos manipular um Error.

Existem duas formas de declarar as assertivas

1. assert(num >= 0);

2. assert(num >= 0) : “O valor de num eh: “ + num;

Como usar? É preciso ativar?

As assertivas foram adicionadas na versão 1.4 do Java, e para utilizarmos em tempo de execução é necessário ativar. Veja como:

java –ea br.com.certificacao.Teste ou java –enableassertions br.com.certificacao.Teste

e se desejar desativar (já é desativado por padrão):

java -da br.com.certificacao.Teste ou java -disableassertions br.com.certificacao.Teste

Vamos fazer um teste:

1. Crie uma classe MinhaClasseTeste.java no seu diretório home.

public class MinhaClasseTeste {

public static void main(String[] args) {

int num = -3;

assert(num > 0) : “A variavel num eh: “ + num;

System.out.println(“Ok”);

}

}

2. Compile: javac MinhaClasseTeste.java

3. Execute: java -ea MinhaClasseTeste

Resultado: Exception in thread “main” java.lang.AssertionError: A variavel num eh: -3

4. Execute: java -da MinhaClasseTeste

Resultado: Ok

E se depararmos com um código antigo que tinha um atributo chamado assert?

Será necessário compilar a classe usando o seguinte comando:

java –source 1.3 br.com.certificacao.Teste

E se executarmos uma classe com assert, mas utilizando o parâmetro padrão –da?

A JVM simplesmente irá ignorar o comando assert.

Quando devemos usar? (apenas sugestão)

• Devemos usar em testes para nos pouparmos de manipular exceções.
• Em método privados.

Quando não devemos usar? (apenas sugestão)

• Em métodos públicos.
• Em casos que afetam outros atributos:

assert(chamaMetodo());

public boolean chamaMetodo() {

usuario.ativar(); // altera atributo.

return true;

}

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje vamos falar sobre um assunto bem interessante que é exceções.

Assuntos

1. Exceções
2. Exceções e herança

1. Exceções

As exceções são representadas pela classe Throwable. Veja a hierarquia:

Object

|

`- Throwable

|

`- Exception

|      |

|      `- RuntimeException

|

`- Error

O que é cada uma delas?

• Throwable – O pai de todos os santos.
• Error – Representa situações incomuns que não são causadas por erros no programa. Ex: OutOfMemoryError.java (Quando a JVM fica sem espaço de memória).
• Exception – São exceções que podem ser capturadas e tratadas (try/catch).
• RuntimeException – São exceções não esperadas que ocorrem em tempo de execução como por exemplo ArithmeticExcetion.java (divisão por zero).

Regras básicas

1. Todas as exceções podem ser tratadas (try/cath), mas as que herdam de Error talvez não sejam possíveis tratar.
2. Se o método não lançar exceção (throws) não será possível tratar (try/catch) a não ser que o catch seja Exception.
3. É possível criar blocos try/catch e try/finally (sem necessidade).
4. O bloco finally não é obrigatório.
5. Se declarado o bloco finally, sempre será executado após o try ou o catch.
6. Os blocos catch serão analisados na ordem em que forem declarados.

Exceções mais conhecidas

• ArrayIndexOutOfBounException - Lançada ao se tentar acessar um array com um valor de índice inválido (ou negativo ou maior do que o tamanho do array).
• ClassCastException - Lançada ao se tentar converter uma variável de referência em um tipo que não passa no teste É-UM.
• IllegalArgumentException - Lançada quando um método recebe um argumento formatado de forma diferente do que espera.
• IllegalStateException – Lançada quando um método é invocado em um momento ilegal ou impróprio. Em outras palavras, a aplicação Java não está em um estado apropriado para a operação solicitada.
• NullPointerException - Lançada ao se tentar acessar um objeto com uma variável de referência cujo atual seja null.
• NumberFormatException - Lançada quando um método que converte uma String em um número recebe uma String que não representa um número.
• AssertionError - Lançada quando um método boolean de uma instrução retorna false. Ex: assert. Veremos mais para frente.
• ExceptionInInitializerError - Lançada ao se tentar inicializar uma variável estática a um bloco de inicialização.
• StackOverflowError - Normalmente lançada quando um método faz recursões profundas demais.

Vejamos alguns exemplos:

public class ManipulandoError {

public static void main(String[] args) {

ManipulandoError m = new ManipulandoError(); m.metodoA();

}

void metodoA() throws Error { throw new Error(); }

void metodoB() {

try {

metodoA();

} catch (Error e) {

System.out.println(“erro”);

}

}

}

Console:

Exception in thread “main” java.lang.Error

Se você esperava imprimir “erro” no console se enganou, porque a JVM viu que era um Error e então lançou o erro.

public class ManipulandoTryCatch {

public static void main(String[] args) {

ManipulandoTryCatch m = new ManipulandoTryCatch();

m.metodoA();

m.metodoC();

}

void metodoA() {

try { metodoB();

} finally { System.out.println(“Incrivel o que Java permite! (try/finally)”); }

try { metodoB();

} catch (Exception e) { System.out.println(“Incrivel o que Java permite! (try/catch)”); }

try { metodoB();

} catch (MinhaExcecao e) { } // Aqui NAO COMPILA mesmo sabendo que MinhaExcecao E-UMA Exception

}

void metodoB() { }

void metodoC() {

try { metodoD(); System.out.println(“try”);

} catch (MinhaExcecao e) { System.out.println(“catch”);

} finally { System.out.println(“finally”); } // Sempre será executado o bloco finally

}

void metodoD() throws MinhaExcecao { throw new MinhaExcecao(); }

}

class MinhaExcecao extends Exception { private static final long serialVersionUID = 1L; }

2. Exceções e herança

Regras básicas

1. Entre os blocos catch, as mais específicas devem ser declaradas primeiro.
2. Quando uma exceção for herdada por RuntimeException não será necessário tratar (try/catch).

Vejamos alguns exemplos:

public class ManipulandoHeranca {

private class PaiException extends Exception {}

private class FilhoDeSangueException extends PaiException {}

private class FilhoAdotadoException extends PaiException {}

public static void main(String[] args) {

new ManipulandoHeranca().metodoA();

}

void metodoA(){

try { motodoB();

} catch (FilhoDeSangueException e) { System.out.println(“filho de sangue”);

} catch (FilhoAdotadoException e) { System.out.println(“filho adotado”);

} catch (PaiException e) { System.out.println(“pai”);

}

}

private void motodoB() throws PaiException { throw new FilhoDeSangueException(); }

}

• No exemplo acima, se substituirmos o throws PaiException por throws FilhoDeSangueException o código não irá compilar, porque nunca poderá ser executada.
• Também no exemplo acima, se colocássemos catch (PaiException e) em primeiro lugar, não compilaria porque como vimos acima deve ser declarado primeiro as exceções específicas.

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Hoje iremos ver dois assuntos bem utilizados no nosso dia-a-dia de programação. E para entendermos melhor iremos ver alguns exemplos.

Assuntos

• Instrução switch.
• Conceitos básicos e importantes sobre loops e iteradores.

Instrução switch

Regras básicas

• A expressão switch deve avaliar um char, byte, short, int ou Enum.
• O argumento que uma instrução case poderá avaliar, deve ser do mesmo tipo que a instrução switch.
• O valor da instrução case deve ser uma constante no tempo de compilação.
• Não pode ter instruções case como o mesmo valor.
• Nem toda instrução case precisa ter obrigatoriamente a instrução break.
• Caso não tenha uma instrução break a JVM irá executar todos os blocos subsequentes.
• A instrução default não precisa estar obrigatoriamente após a ultima instrução case.

Veja exemplos e pegadinhas:

1.

public static void main (String[] args) {

final int zero = 0;

final int um;

um = 1;

int x = 1;

switch (x) {

case zero: break;

case um: // não compila porque não é uma constante em tempo de compilação

// apesar de ser final o valor de “um” só será atribuido em tempo de execução

break;

}

}

2.

public static void main(String[] args) {

byte x = 1;

switch (x) {

case 1: break;

case 128: // não compila porque 128 é maior que um byte

break ;

}

}

3.

enum Teste { UM, DOIS, TRES }

public static void main(String[] args) {

Teste x = Teste.DOIS;

switch (x) {

case UM : System.out.println(“UM”); break;

case DOIS: System.out.println(“DOIS”); // nao tem break. Executa todos os subsequentes

case TRES: System.out.println(“TRES”); break;

}

}

Resultado Console

DOIS

TRES

4.

enum Teste { UM, DOIS, TRES, CEM }

public static void main(String[] args) {

Teste x = Teste.CEM;

switch (x) {

case UM: System.out.println(“UM”); break;

default: System.out.println(“default”); // nao tem break. Executa todos os subsequentes

case DOIS: System.out.println(“DOIS”);

case TRES: System.out.println(“TRES”); break;

}

}

5.

enum Teste { UM, DOIS, TRES, CEM }

public static void main(String[] args) {

Teste x = Teste.CEM;

switch (x) {

case UM: System.out.println(“UM”); break;

case DOIS: System.out.println(“DOIS”); break;

case TRES: System.out.println(“TRES”); break; // não compila porque está repetindo na instrução abaixo

case TRES: System.out.println(“TRES”); break;

}

}

Conceitos básicos e importantes sobre Loops e Iteradores

Em Java podemos fazer loops em três formas diferentes: while, do, for.

Usando loops “while”

1. O corpo do bloco while será executado até que a expressão retorne false, ou seja, só será executado o corpo caso a expressão retorne true.

while (expressaoBoolean){

// corpo

}

Usando loops “do”

1. O corpo do bloco do sempre será executado a primeira vez e as próximas só serão executadas quando a expressão retorne true.

do {

// corpo

} while (expressaoBoolean);

Usando loops “for (simples)” e “for-each (aprimorado)”

1. A estrutura do for (simples) é dividida em três partes: Inicialização, Condição e Iteração.
2. O corpo do for (simples) será executado até que a Condição falhe, ou seja, retorne false.
3. As partes do for (simples) não são obrigatórios
4. A estrutura do for-each (aprimorado) é dividida em duas partes: Declaração e Expressão(Array).
5. O corpo do for-each (aprimorado) será executado até que a Expressão (Array) tenha conteúdo.

// for (simples)

// compila porque as partes nao sao obrigatorias

for (/* Inicializacao */ ; /* Condicao */ ; /* Iteracao */){

// corpo

}

// for-each (aprimorado)

int[] array = { 1, 2, 3, 4 };

for (int i : array) {

// corpo

System.out.println(i);

}

Usando continue e break

1. A palavra continue encerra a execução do corpo e vai para o próximo item do loop.
2. A palavra break encerra a execução do loop e vai para o próximo comando abaixo do loop.

Mas se tem um loop dentro do outro como determinar qual deve ser parado?

Simples. Criando um alias. Veja o exemplo abaixo:

int[] array = { 1, 2, 3, 4 };

boolean teste = false;

aliasFor : for (int i : array) {

System.out.println(i);

while (teste){

break aliasFor;

}

teste = true;

}

Resultado:

1

2

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

vamos começar a ver nesse capítulo os controles de fluxo mais utilizados.

Assuntos

• if, else e else if

Regras

• A expressão avaliada deve ser obrigatoriamente um valor boolean.
• Não precisa obrigatoriamente ter as chaves { } (begin, end respectivamente).
• Quando não aparecer as chaves será executada apenas a primeira linha abaixo da condição if, else ou else if.
• Quando não aparecer as chaves e aparecer a condição else ou else if, a mesma pertencerá ao if mais próximo. Veja o exemplo abaixo:

public static void main(String[] args) {

boolean ok = false; boolean testeOk = false;

if (ok)

if (testeOk)

System.out.println(“Teste Ok!”);

else

System.out.println(“Nao Ok”);

}

No exemplo acima você se engana pela identação e pela falta das chaves begin e end, e acha que irá imprimir “Nao Ok” no console, mas na verdade não irá imprimir nada. Porque o else pertence ao if mais próximo.

Outra pegadinha:

public static void main(String[] args) {

boolean ok = false;

if (ok = true)

System.out.println(“Ok”);

}

O exemplo acima você pode imaginar 3 coisas:

• O código não irá compilar porque o operador é de atribuição é não de igualdade
• A condição será false porque o atributo tem o valor false anteriormente.
• A condição será true porque atribuiu o valor true.

A terceira está correta porque ok é boolean e a JVM primeiro executa a expressão e depois avalia, imagine que ok = true é um método que retorna boolean.

Outro exemplo interessante:

public static void main (String[] args) {

int b;

boolean a = true;

if (a) {

b = 10;

}

System.out.println(b);

}

Esse código não compila, pois a JVM reclama que a variável b não foi inicializada.

public static void main(String[] args) {

int b;

if (true) {

b = 10;

}

System.out.println(b);

}

Esse código compila, pois a JVM entende que com certeza vai entrar no if.

É isso ai pessoal, compartilhem, comentem e estudem!

Escrito por Marcos Oto Picarelli Prado

Com o novo modelo de replicação do PostgreSQL, torna-se viável a utilização de balanceamento de carga nas operações de leitura, uma vez que os servidores de contingência permanecem em modo read-only (Hot Standby). Até a versão 8.4, o balanceamento de carga só era possível se utilizado juntamente com ferramentas de replicação de terceiros, por exemplo Slony.

Apesar de ser uma replicação Master/Slave assíncrona, a funcionalidade Streaming Replication do PostgreSQL 9.0 garante uma replicação consistente e com atraso praticamente imperceptível para o usuário final. Este comportamento viabiliza a utilização dos servidores de contingência, denominados slaves, como fonte de dados atualizada, reduzindo a carga de leitura sobre o servidor master.

A ferramenta Pgpool-II possui a funcionalidade de balanceamento de carga, que visa distribuir operações de leitura entre os servidores envolvidos. Pensando na popularidade da replicação do PostgreSQL 9.0, o grupo de desenvolvedores do Pgpool-II acrescentou algumas funcionalidades específicas de integração com a nova versão do PostgreSQL, lançando a versão 3.0 do Pgpool-II.

A seguir um cenário possível envolvendo PostgreSQL 9.0 e Pgpool-II 3.0:

Pgpool-II é um software intermediário(middleware) entre a aplicação(frontend) e o servidor PostgreSQL(backend). Age de forma transparente e suporta até 128 nós de replicação. Pode-se considerar as seguintes funcionalidades principais:

Pooling de conexões (Aglomerador de conexões)

• Mantém conexões abertas com o servidor PostgreSQL, reutilizando-as para novas conexões com as mesmas propriedades.
• Reduz o overhead causado pela abertura de novos processos (fork) no servidor PostgreSQL.

Fonte: Pgpool Global Development Group

As conexões são fechadas entre o usuário e o Pgpool-II. O usuário devolve a conexão ao pool, mas as mesmas persistem no servidor de banco de dados para reutilização:

Fonte: Pgpool Global Development Group

Replicação

Permite o envio de todas as operações para todos os servidores PostgreSQL envolvidos.

Balanceamento de carga

Distribui consultas de forma aleatória entre os servidores PostgreSQL envolvidos.

Fonte: Pgpool Global Development Group

Consultas paralelas

Particiona tabelas entre os servidores envolvidos, possibilitando a execução de consultas ao mesmo tempo sobre conjuntos diferentes de dados.A funcionalidade de replicação do Pgpool-II não oferece a consistência necessária para a maioria das aplicações. O modelo de replicação é conhecido como Dual-master, sendo baseado em comandos. Desta forma os comandos são executados em cada servidor, tornando possível a existência de bases de dados com informações diferentes quando utilizadas funções que retiram informações do servidor. Por exemplo: now() e random().

A paralelização de consultas não é o foco deste artigo, mais informações sobre estas funcionalidades estão disponíveis no site do projeto http://pgpool.projects.postgresql.org/.

Para o ambiente em questão utiliza-se apenas as füncionalidades de pool de conexões e balanceamento de carga.

A versão 3.0 do Pgpool-II provê a este ambiente, as seguintes características:

• Failover automático através da detecção de falha no processo monitor do Pgpool-II e execução de comando definido no parâmetro failover_command;
• Modo de balanceamento Master/Slave específico para Streaming Replication;
• Interpretação de comandos (parser) para distinguir comandos de alteração e consultas;
• Verificação do atraso do servidor slave em relação ao master. Caso o atraso exceda o valor definido no parâmetro delay_threshold, as consultas só serão enviadas ao servidor master;
• Possibilidade de adição de servidores slaves sem reiniciar o serviço do Pgpool.

Para que o próprio servidor do Pgpool-II não seja um ponto único de falha, pode-se configurar uma réplica do servidor. O script pgpool-HA é um recurso do software Heartbeat que pode garantir o serviço do Pgpool-II sempre ativo independente do servidor.

A ferramenta web Pgpooladmin pode auxiliar na administração das funcionalidades do Pgpool-II. Instalada no próprio servidor do Pgpool-II ela facilita tarefas de monitoramento, administração do processo e alterações na configuração. Estas ferramentas auxiliares estão disponíveis no site do projeto http://pgfoundry.org/projects/pgpool/.

A análise de ferramentas de alta disponilidade e desempenho para servidores PostgreSQL é o foco do Treinamento PostgreSQL Alta disponibilidade, promovido pela Dextra Sistemas. Este e outros ambientes são configurados pelos próprios alunos durante treinamento, visando capacitar o aluno na escolha e implantação da tecnologia adequada em ambientes corporativos.

A Dextra oferece também serviços de consultoria e suporte em várias modalidades, incluindo suporte 24×7, garantindo o desempenho e a alta disponibilidade exigida em servidores de banco de dados.

• ocorrência de checkpoint de acordo com o intervalo de tempo definido no parâmetro checkpoint_timeout;
• preenchimento de certa quantidade de segmentos de logs de 16 MB, definida no parâmetro checkpoint_segments;
• ocorrência de cópia de segmentos de logs de acordo com intervalo de tempo definido no parâmetro archive_timeout.

A ferramenta do contrib do PostgreSQL, pg_standby, inicia um processo no servidor slave que aguarda por segmentos de logs enviados de tempos em tempos pelo servidor master e aplica-os no servidor de contingência. Porém, o servidor de contingência permanece iniciado exclusivamente para o processo pg_standby, ou seja, em modo de recuperação.

Replicação Warm Standby

Portanto, tem-se nesta solução de alta disponibilidade um intervalo razoável de atualização do servidor slave, além do mesmo não permitir acesso para consultas.
A partir da versão 9.0, a opção da criação de um canal de comunicação (stream) entre os servidores foi implementada, tornando a replicação mais eficiente. Esta nova funcionalidade é chamada de streaming replication.

A streaming replication permite que um servidor slave permaneça em comunicação constante como servidor master, facilitando o recebimento de segmentos de logs. Isto é possível devido aos processos Walreceiver e Walsender, iniciados nos servidores slave e master respectivamente. Esses processos utilizam um canal de comunicação criado via TCP/IP. A criação desse canal inicia-se quando o Walreceiver envia uma requisição de conexão ao servidor master, se a conexão for estabelecida, o processo Walsender é criado. A partir de então o Walsender envia ao Walreceiver as alterações efetivadas no servidor master a serem aplicadas no servidor slave.

Diferente da replicação warm standby, a streaming replication envia somente as alterações, sem considerar critérios de rotação de segmentos de logs definidos no servidor master.

Assim como na warm standby, a streaming replication também é uma replicação assíncrona, por isso ainda há um pequeno atraso entre submeter uma transação no servidor master e essas mudanças se tornarem visíveis no servidor slave. O atraso, no entanto, é muito menor se comparado com o envio de logs baseado em arquivo.

Replicação Streaming Replication/Hot Standby

Um indicador importante da eficiência da streaming replication é a quantidade de registros do WAL gerados no servidor master, mas ainda não aplicado no servidor slave. Pode-se calcular esse atraso, comparando a localização atual do WAL no servidor master com a localização do WAL recebido pelo servidor slave. Essas informações podem ser recuperadas usando as funções pg_current_xlog_location no servidor master e pg_last_xlog_receive_location no servidor slave. A ultima localização do WAL recebida pelo servidor slave também é exibida no status do processo Walreceiver.

Além desta nova característica, o sistema de replicação nativo do PostgreSQL, conta com uma nova funcionalidade, na qual as bases replicadas permanecem em modo read-only, onde são possíveis somente comandos de leitura (hot standby).

O termo hot standby se refere à capacidade do servidor slave mover operações de recuperação para operações normais, ou seja, possibilitar a execução de consultas ao mesmo tempo em que as alterações efetivadas no servidor master estejam sendo replicadas. Isto é útil tanto para fins de replicação quanto para restaurar um backup para um estado desejado com grande precisão (PITR).

A replicação streaming replication/hot standby garante a segurança sem afetar significativamente a performance do servidor de produção. A replicação do servidor master para vários slaves possibilita a definição de estratégias de alta disponibilidade, sem a necessidade de ferramentas de terceiros.

Portanto o PostgreSQL 9.0, realça ainda mais o objetivo da comunidade de software livre em desenvolver um SGBD cada vez mais avançado e robusto. Visando assim, atender as necessidades de ambientes corporativos que exigem segurança, performance e alta disponibilidade dos dados.

Este tipo de replicação já faz parte do conteúdo do curso de Alta Disponibilidade promovido pela Dextra Sistemas. Esta e outras estratégias de replicação praticadas no treinamento, fornecem ao aluno o conhecimento necessário para definir estratégias de alta disponibilidade voltadas a diversos ambientes.

Olá pessoal,

Está disponível para download a versão 8.4 do PostgreSQL.

Após 16 meses de desenvolvimento, foram adicionadas quase 300 melhorias em todos os aspectos do SGBD, para mais detalhes clique aqui.

A atualização para a versão 8.4 é altamente recomendada.

• Foram desenvolvidas e aperfeiçoadas ferramentas de administração e monitoramento.
• Novos comandos foram adicionados para tornar a programação em banco de dados mais simples e compacta.
• Características avançadas do padrão SQL ANSI 2003 de windowing functions, common table expressions e consultas recursivas permitem a elaboração de relatório complexos em uma única consulta.
• Melhorias de performance em todos os aspectos. Destaque para otimização do tempo de restauração do banco e tempo de execução de consultas (semi-join e anti-join).

O grupo de desenvolvedores do PostgreSQL visa a cada versão tornar a administração e desenvolvimento nesse banco de dados mais fácil e produtivo, sem deixar de lado as características de robustez e performance que consagraram o SGBD livre mais avançado do mundo.

Confira a lista completa de cursos e consultoria PostgreSQL oferecida pela Dextra.

Os benefícios dessa replicação são muitos, fato que levou o grupo de desenvolvedores do PostgreSQL a se dedicar na criação e aperfeiçoamento de suas funcionalidades, o que antes ocorria com a ferramenta de replicação Slony-l. Como resultado dessa dedicação pode-se esperar o aumento constante do uso do Warm Standby para prover alta disponibilidade no PostgreSQL.

A partir da versão 8.2 do PostgreSQL, foi incorporada uma contrib chamada pg_standby. Este utilitário é responsável pelo gerenciamento da réplica que permanecerá em constante restauração dos logs de transação recebidos pelo servidor de produção até o momento da falha (crash) do mesmo, ocorrendo então o failover.
Com o pg_standby é possível uma replicação consistente sem ocasionar relevantes impactos à performance do sistema. Esta relação desempenho e consistência é um desafio para as soluções de replicação de banco de dados, sendo essa característica o maior benefício da replicação Warm Standby. Mas as vantagens não param por aí, o pg_standby permite também a recuperação imediata do servidor Standby, tornando-o disponível para acesso segundos após o crash do servidor de produção. Configuração de limpeza dos logs já restaurados ou armazenamento dos mesmos para backup e restauração PITR (Point in Time Recovery) também oferecem grande vantagem.

Para melhor compreender as vantagens do Warm Standby, basta analisar o funcionamento interno do PostgreSQL em relação a utilização dos logs de transação.
SGDBs avançados utilizam intensamente a memória principal para obter desempenho no gerenciamento dos dados. Por outro lado, dados em memória são perdidos na ocasião de uma falha inesperada no servidor. Surge então, a necessidade de um armazenamento intermediário no próprio disco, porém com uma característica que permita o acesso rápido na leitura e escrita. Para suprir essa necessidade são utilizados os logs transacionais, que possuem estrutura seqüencial para facilitar o acesso ao disco. No PostgreSQL esses logs são denominados WAL (Write Ahead Logs), estão presentes no diretório $PGDATA/pg_xlog e possuem por padrão 16MB (Ver figura 1). Em um intervalo de tempo configurado ou através de comando SQL, as transações que sofreram COMMIT são transferidas do WAL para o arquivo de dados e os logs são reciclados, essa operação é conhecida como CHECKPOINT.

Figura 1 – Diretório do WAL

De tempos em tempos, as transações em memória são gravadas no WAL. As que sofreram COMMIT em memória podem ser gravadas de forma síncrona nos logs. A partir do momento que as transações estão nos logs, elas já podem ser recuperadas em caso de crash no banco de dados. Mas, e as transações que não sofreram COMMIT antes do crash? Foram perdidas, pois estavam totalmente em memória ou desfeitas se parcialmente gravadas no WAL. Observando a figura 2, pode-se entender o que acontece com as transações, nos seus possíveis estados, em caso de crash no banco de dados:

Figura 2 – Gerenciamento de transações

O PostgreSQL utiliza um método conhecido como REDO para recuperar transações presentes no WAL. O REDO consiste em refazer toda a transação através das informações contidas no WAL. Sendo assim, em caso de falha, a transação TR1 da figura acima, estaria no arquivo de dados após o CHECKPOINT, portanto não necessitaria de recuperação. A TR2 e a TR3 estariam completamente no WAL, sendo necessário o REDO para refazê-las totalmente. A TR4 sofreria o ROLLBACK do sistema e para TR5 nada precisaria ser feito, pois foi eliminada na memória.

Mas e a replicação, como acontece? Com a cópia base do banco principal no servidor Standby, após o CHECKPOINT e antes da reciclagem, os arquivos WAL podem ser transferidos para um diretório do servidor Standby. O pg_standby é responsável pela aplicação dos logs no arquivo de dados do servidor Standby, aguardar o sinal para finalizar a restauração e disponibilizar o acesso imediato ao banco recuperado.

Reforçando tecnicamente as vantagens, o arquivamento do WAL ocorre em paralelo e de forma assíncrona, portanto não interfere no desempenho do banco de dados. A constante restauração do servidor Standby, permite o início imediato do mesmo após o crash do servidor principal. Os logs podem permanecer para backup, tanto no servidor principal, quanto no servidor Standby ou podem ser eliminados após a restauração. Todo o processo de sincronização entre memória e WAL, WAL e arquivo de dados, arquivamento, transferência e restauração dos logs podem ser configurados baseados no ambiente em que está inserido. Esta técnica pode ser combinada com técnicas de identificação de indisponibilidade do servidor, podendo todo o processo ser automatizado ou monitorado.

Melhorias para essa técnica de replicação são esperadas para a versão 8.5 do PostgreSQL. Dentre elas destacam-se a implementação da replicação síncrona, conhecida como Hot Standby, o arquivamento de transações que ainda estão em memória e a disponibilização do servidor Standby para leitura.

Concluindo, esta é uma técnica de replicação que pode ser ideal para vários ambientes, porém existem várias técnicas para implementação de alta disponibilidade em ambientes críticos. A Dextra possui grande experiência na implementação de alta disponibilidade no PostgreSQL, disponibilizando esse conhecimento no treinamento de Alta disponibilidade, onde o aluno será habilitado a configurar alta disponibilidade através do PostgreSQL Warm Standby e ferramentas como SLony-I, Pgpool, entre outras.

Como o intuito de disseminar conhecimento, a Dextra Sistemas lançou este espaço para que nós, Administradores de Banco de Dados, possamos compartilhar nossas experiências diárias sobre o tema.

Neste primeiro post falaremos sobre o PostgreSQL, apresentando de forma resumida, duas funcionalidades que estarão disponíveis na versão 8.4, com lançamento previsto para maio ou junho deste ano. Uma versão beta da versão 8.4 já está disponível no site www.postgresql.org.

Um problema recorrente que os administradores de bancos de dados encontram é em relação à configuração da codificação (conhecida como charset ou encoding) e localização (conhecida como locales) em aplicações de ambientes que possuem regras heterogêneas de linguagens e países distintos. Localização são regras que definem parâmetros de ordenação, classificação e agrupamento da informação de acordo com a localidade e a linguagem de cada região.

Em aplicações onde se tenha o requisito de suporte a múltiplas regras de localidade, precisamos que o servidor de banco de dados possua suporte, e a boa notícia é que o PostgreSQL, a partir da versão 8.4 terá esse suporte. Na nova versão, o PostgreSQL se desprende da codificação e da localização do sistema operacional e permite que em um mesmo cluster seja possível trabalhar com distintas codificações e localizações.

Após uma contextualização e a importância de se possuir uma flexibilidade e adaptação a qualquer conjunto de regras (locales), é apresentado como implementar esta funcionalidade no PostgreSQL.

Primeiro é necessário realizar a conexão a um banco de dados, e em seguida executar o comando create database.

A conexão com o PostgreSQL pode ser realizada a partir da seguinte linha:

psql postgres -U postgres

O próximo passo é a criação do banco de dados na codificação e localização desejada.

CREATE DATABASE dextra ENCODING='Latin1' COLLATE='pt_BR' CTYPE='pt_BR' TEMPLATE=template0;

Um detalhe é importante: Ao criar um banco de dados e especificar um locale diferente do padrão do cluster é necessário usar o template0 como template.

Uma forma de visualizar o banco, sua respectiva codificação e localização é:

SELECT datname,pg_encoding_to_char(encoding),datcollate,datctype FROM pg_database;

Um outro problema enfrentado pelos administradores de banco de dados é o momento de realizar um processo de restore, quando este é relativamente grande. Como uma solução de minimizar este problema, a partir da versão 8.4 será possível paralelizar o processo de restauração. Isso poderá ser feito através do parâmetro -m (multi-thread) do utilitário pg_restore.