segunda-feira, 25 de fevereiro de 2013

O elemento <canvas> do HTML5

O "<canvas>" é um container (uma área retangular) do HTML 5 para desenhar gráficos em tempo de execução, através de scripts (normalmente JavaScript).

O exemplo abaixo ilustra o desenho de um canvas com 100px de largura e 100px de altura, com uma borda de 1px:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<canvas id="meuCanvas1" height="100" width="100" style="border:1px solid #000000;"></canvas>

Dentro desse canvas, é possível desenhar diferentes formas geométricas.

Para desenhar linhas ("paths"), por exemplo, podemos utilizar os métodos "moveTo()" e "lineTo()", conforme o exemplo abaixo:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<script>
//pega uma referência do canvas "meuCanvas"
var c = document.getElementById("meuCanvas");
//pega uma referência pro contexto 2D do canvas
var ctx = c.getContext("2d");
//move o "pincel" para a posição x=0 e y=0 (aqui será o início da linha)
ctx.moveTo(0,0);
//determina a posição final da linha como sendo x=50 e y=75
ctx.lineTo(50,75);
//desenha a linha conforme as coordenadas passadas anteriormente
ctx.stroke();
</script>

Para desenhar um retângulo, podemos utilizar o método "fillRect()", conforme o exemplo abaixo:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<script>
var c = document.getElementById("meuCanvas");
var ctx = c.getContext("2d");
//define a cor de preenchimento
ctx.fillStyle="#0000FF";
//cria um retângulo nas coordenadas x=0 e y=0, de largura 50px e altura 50px.
ctx.fillRect(0,0,50,50);
</script>

Já para desenhar um círculo, podemos utilizar o método "arc()", conforme o exemplo abaixo:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<script>
var c = document.getElementById("meuCanvas");
var ctx = c.getContext("2d");
ctx.beginPath();
//o círculo começará a ser desenhado nas posições x=25 e y=25 e terá um raio 10px
ctx.arc(50,50,25,0,2*Math.PI);
ctx.stroke(); //ou ctx.fill() pro círculo ficar pintado
</script>


Além de desenhar formas geométricas, também é possível desenhar textos no canvas, através dos métodos "fillText()" ou "strokeText()", conforme o exemplo abaixo:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<script>
var c = document.getElementById("meuCanvas");
var ctx = c.getContext("2d");
ctx.font="18px Arial";
ctx.fillText("Bom dia! =)",5,50);
</script>


Por fim, utilizando o que já foi apresentado, podemos desenhar a bandeira do Brasil (simplificada), conforme o exemplo abaixo:

Visualização:
Your browser does not support the HTML5 canvas tag.
Código fonte:
<canvas id="myCanvas5" width="250" height="150" style="border:1px solid #d3d3d3;"/>

<script>
var c = document.getElementById("myCanvas5");
var ctx = c.getContext("2d");

//Desenha a retângulo verde
ctx.fillStyle="green";
ctx.fillRect(0,0,250,150);

//Desenha o losango amarelo
ctx.fillStyle = "#FCFF00";
ctx.beginPath();
ctx.moveTo(125,0);
ctx.lineTo(250,75);
ctx.lineTo(125,150);
ctx.lineTo(0, 75);
ctx.lineTo(125,0);
ctx.fill();
ctx.closePath(); 

//Desenha o círculo azul
ctx.beginPath();
ctx.fillStyle="#00027F";
ctx.arc(125,75,50,0,2*Math.PI);
ctx.fill();
ctx.closePath();

//Desenha a faixa branca
ctx.fillStyle="#FFFFFF";
ctx.fillRect(75,65,100,15);

//Desenha o texto
ctx.beginPath();
ctx.fillStyle="#000000";
ctx.font="10px Arial";
ctx.fillText("Ordem e Progresso",80,75);
ctx.fill();
ctx.closePath();

</script>

Bom, esses são apenas algumas questões iniciais sobre o que pode ser feito com o elemento "<canvas>" do HTML 5. Existem muitas questões não abordadas aqui e inúmeros exemplos de desenhos complexos na Web - basta ter interesse e começar a praticar!

segunda-feira, 18 de fevereiro de 2013

Ciclo de vida do Hibernate

O Hibernate é um framework ORM (mapeamento objeto-relacional) - inserindo, removendo ou atualizando registros em tabelas de banco de dados, dependendo de operações feitas sobre objetos de persistência associados a essas tabelas.

Além de abstrair as operações feitas sobre o sistema de banco de dados utilizado, é possível gerenciar os estados dos objetos manipulados pelo framework. Dessa forma, os desenvolvedores devem sempre ter em mente o estado de seus objetos, e não necessariamente a execução de comandos SQL (esse tipo de preocupação aparece mais em processos de "tuning" da aplicação).

Os objetos de persistência manipulados pelo Hibernate possuem 3 estados: "transient", "persistent" e "detached":

  • Um objeto é transiente se ele acabou de ser instanciado (através do operador "new") e não está associado a um objeto "Session" do Hibernate. Ele não tem uma representação na base de dados e nenhum identificador foi associado a ele. Essas instâncias serão destruídas pelo "Garbage Collector" se a aplicação não mantiver mais uma referência para elas.
  • Pessoa pessoa = new Pessoa();
    pessoa.setName("João");
    //objeto Pessoa está no estado 'transient'
    

  • Um objeto persistente tem uma representação na base de dados e um identificador associado a ele. Ele pode ter sido acabado de ser salvo ou carregado e está no escopo do objeto "Session". O hibernate vai detectar qualquer alteração feita no objeto e atualizar a base de dados assim que possível (operação de "flush" dos dados).
  • Long id = (Long) session.save(pessoa);
    //objeto Pessoa agora está no estado 'persistent'
    

  • Um objeto "destacado" ou "separado" foi persistente, mas sua sessão ("Session") foi fechada. A referência para o objeto ainda existe e ele ainda pode ser alterado. Mais tarde, uma instância desse tipo pode ser "religada" a um novo objeto "Session" e suas atualizações podem então ser persistidas novamente.
  • session.close();
    pessoa.setName("João Paulo");
    //objeto Pessoa está no estado 'detached'
    

Obs.: Alguns autores colocam ainda o estado "removido" ("removed") como sendo um quarto estado. Embora possa-se também dizer que o método "delete()" coloque um objeto persistente no estado transiente novamente.

A figura abaixo apresenta os estados descritos e possíveis operações envolvidas nas mudanças de estados.

Não convém, nesse momento, detalhar cada uma dessas operações; mas já se pode ter uma boa noção do ciclo de vida dos objetos de persistência manipulados pelo Hibernate em uma aplicação.

domingo, 10 de fevereiro de 2013

Como gerar automaticamente as tabelas do banco com o Hibernate

O Hibernate possui uma facilidade para criação das tabelas do banco de dados a partir das entidades definidas no modelo da aplicação, é a classe "SchemaExport".

Através dessa classe, pode-se gerar o script DDL para qualquer banco suportado pelo Hibernate, e configurado para ser utilizado por esse framework de persistência.

Segue abaixo um exemplo de uma possível forma de utilizar essa classe.

private void geraTabelas(){
    //AnnotationConfiguration cfg = new AnnotationConfiguration(); //deprecated
    Configuration cfg = new Configuration();
    //Entidades do modelo sendo adicionadas na configuração
    cfg.addAnnotatedClass(Vendas.class);
    cfg.addAnnotatedClass(Clientes.class);
       
    SchemaExport schemaExport = new SchemaExport(cfg);
    schemaExport.create(true, true);
}

O método "create" possui dois argumentos booleanos: o primeiro indica que deseja-se ver o código SQL de geração das tabelas, e o segundo se deseja-se executá-lo (pois pode-se querer apenas visualizar o SQL, para fazer adaptações nesse código ou executá-lo diretamente em um cliente de banco de dados).

Obs.: Lembrando que a versão 4 do Hibernate utiliza a classe "Configuration", ao invés da classe "AnnotationConfiguration", utilizada nas versões anteriores.

Uma questão importante é que, ao rodar esse método, o Hibernate vai fazer executar também um comando SQL "DROP TABLE" com os nomes das tabelas a serem criadas. Se a intenção é apenas atualizar as tabelas com novos campos (relacionados a novos atributos das classes que representam as entidades), deve-se utilizar a classe SchemaUpdate.

sexta-feira, 8 de fevereiro de 2013

Hibernate

No que diz respeito aos frameworks de persistência de dados para Java, o Hibernate - que é uma solução open-source - é hoje em dia um dos mais utilizados, principalmente em se tratando de tecnologias que implementam o padrão JPA. De fato, o Hibernate foi a inspiração para o desenvolvimento da especificação JPA.

De forma geral, o Hibernate pode ser definido como sendo uma ferramenta de mapeamento objeto-relacional*. Essas ferramentas são muitas vezes identificadas pela sua sigla em inglês "ORM" (Object-relational mapping).

De forma simplista, o Hibernate abstrai o código SQL, que é gerado em tempo de execução pelo framework para diferentes bancos de dados. Com isso, ele facilita o desenvolvimento de um sistema orientado a objetos, facilitando também sua legibilidade, manutenção e migração para outros bancos, podendo diminuir o custo dos projetos.

Obs.: Na verdade, hoje em dia, o Hibernate é uma coleção de projetos relacionados, vinculados à comunidade JBoss, que normalmente manipulam modelos baseados em objetos POJO. Dentre esses projetos, o mais clássico é o framework de persistência que está sendo tratado nesse post, o Hibernate ORM (ou, simplesmente, Hibernate). Outros projetos, como o Hibernate Search, o Hibernate Shards, o Hibernate Metamodel Generator, o Hibernate OGM e o Hibernate Validator, também fazem parte dessa coleção de projetos.

No momento em que foi escrito esse post, a versão estável mais atual do Hibernate é a 4.1. A versão 4 possui algumas diferenças em relação à versão 3, que é mais utilizada no mercado; mas essas diferenças serão exploradas em posts futuros.

A última versão do Hibernate pode ser baixada aqui, ou - utilizando Maven - através desse repositório. A documentação oficial (em inglês), tanto da versão 3 quanto da 4, podem ser encontradas aqui.

Bom, nada do que foi dito neste post é novidade, mas a intenção é que ele seja um ponto de início para futuros posts envolvendo o framework Hibernate.

Novos rumos...

2013 chegou, novas metas foram traçadas e esse blog, que estava parado por questões profissionais e acadêmicas, vai voltar à ativa - dessa vez trazendo informações sobre diversas tecnologias utilizadas no desenvolvimento de sistemas para Web e para ambientes móveis.

O blog antes era acessado pelo endereço "flexao.net" e tinha como foco a plataforma Adobe Flex. A partir de agora, utilizando um novo domínio, tratará de desenvolvimento de sistemas em geral, com notícias atualizadas, dicas de programação, melhores práticas, exemplos no estilo "cook-book", apresentação de componentes e discussões gerais, envolvendo diferentes tecnologias utilizadas no desenvolvimento Web e mobile.

Espera-se, com esse espaço, contribuir de alguma forma com a comunidade brasileira de desenvolvedores de sistemas, aprendendo e crescendo junto com os profissionais que fazem parte dela.