Big Data, e eu com isso?

Esse ano (2013) fui um dos coordenadores da Trilha Big Data no TDC (The Developers Conference).

Big Data é um dos meus estudos que tenho feito.

Muita coisa pode-se falar sobre o conceito. Então, fui convidado para palestrar em Leme para alguns estudantes da região, e escolhi esse tema para falar.

Seguem os slides:

Big data, e eu com isso? from aleuehara

AWS Summit 2013

Seguindo o post sobre Cloud Computing, fiz uma apresentação das palestras assisitidas no AWS Summit 2013 em São Paulo.

Cloud computing from aleuehara

Cloud Computing: Criar um site estático na AWS (Amazon)

Uma das facilidades de hoje em dia é você poder ter quantas máquinas quiser, sem realmente precisar comprar uma.

A nuvem te proporciona isso, a chamada cloud computing.

Cloud Computing

Não vou explicar o conceito de Cloud Computing aqui, mas imagine você precisar testar uma aplicação em um servidor de uma OS específica, de uma versão específica, em uma máquina física específica. Teoricamente você teria que comprar uma máquina, certo? Com a "nuvem", isso não será necessário. Utilizando a Amazon (AWS) por exemplo, você pode ter a máquina, testar e depois descartá-lo.

Existe alguns tipos de serviço na nuvem:

IaaS - Infrastructure as a Service: quando se utiliza uma percentagem de um servidor, geralmente com configuração que se adeque à sua necessidade.
PaaS - Plataform as a Service: utilizando-se apenas uma plataforma como um banco de dados, um web-service, etc. (p.ex.: Windows Azure).
SaaS - Software as a Service: uso de um software em regime de utilização web (p.ex.: Google Docs , Microsoft SharePoint Online).

AWS (Amazon Web Service)

A AWS (http://aws.amazon.com/) é uma das mais completas plataformas para se beneficiar da Nuvem. 

Dentro dela existe vários serviços como:

• Amazon Simple Storage Service (S3)
• Amazon CloudFront 
• Amazon SimpleDB
• Amazon CloudWatch
• Amazon Virtual Private Cloud (VPC)
• Amazon DynamoDB
• Amazon Elastic Compute Cloud (EC2)
• Amazon Elastic MapReduce
• e muitas e muitas outras....

Não vou explicar cada uma delas, pois além de serem muitas, a Amazon lança serviços frequentemente. Alguns serviço vou explicar abaixo ao criar um site estático.

Para ajudar mais ainda, ao cadastrar na AWS, você ganha vários serviços de graça. Dá uma olhada em:

http://aws.amazon.com/pt/free/

Criar um site estático na AWS

Para criar um site estático na AWS, é preciso enteder alguns serviços:

• Amazon Simple Storage Service (S3) - Esse é um serviço de armazenamento. Ou seja aqui é que vamos armazenar todos os arquivos estáticos, como o css, js, imagens, etc.
• Amazon CloudFront - É um serviço web para distribuição de conteúdo. Os arquivos são entregues aos usuários finais usando uma rede global de pontos de presença.

S3

O primeiro passo é entrar no serviço S3 através da console:

1) Crie um bucket no S3 para seus logs

Buket-name: meuprojeto-log (nome do diretório onde vão estar os logs)

Region: São Paulo

Clique em Create e não em Set Up Logging

2) Crie outro bucket no S3

Buket-name: meuprojeto (nome do diretório do seu projeto, do seu site estático)

Region: São Paulo

Clique em: Set Up Logging

Ative o: Enabled

Target Bucket: Referencie ao bucket criado no passo 1

Target Prefix: s3_meuprojeto (ou um prefixo da sua preferência para indentificá-lo)

Não é necessario mudar as configurações dos bucket (permissões) nesse momento se for usar o cloud front.

3) Coloque os arquivos estáticos (html, js, css, imagens, etc) no diretório criado no passo 2

Cloud Front

Entre no serviço Cloud Front

5) Clique em Create Distribution

- Escolha: Download

- Origin Domain Name: referencie o bucket criado (meuprojeto do passo 2), ou se for referenciar fora utilize o dominio de origem (meuprojeto.com.br)

- Origin ID: um nome

- Viewer Protocol Policy: HTTP e HTTPS

- Object Caching: Ao ativar o “Customize” abrirá o campo “minimum TTL”

- Minimum TTL: Coloque em segundos (tempo de cache)

- Forward Cookies: None (imporoves caching) - já que serão objetos estáticos

- Forward Query Strings: No (improves caching)

- Restrict Viewer Access (Use Signed URLs) - nesse local coloque Yes para que os usuário apenas acessem o Cloud Front, e nunca pelo S3 (irá mudar as permissões do S3, que comentei no item 2)

- Trusted Signers: self

- Price Class: Use All Edge Location

- Alternate Domain Names(CNAMEs): Aqui coloque o dominio do seu projeto meuprojeto.com.br - dominio que o usuario irá digitar

- SSL Certificate: default cloud certificate

- Default Root Object: não preencha

- Logging: on (aqui irá habilitar todos os logs de usuários que visitaram a página)

- Bucket for Logs: Referencie o buket criado acima (ex: meuprojeto-log, criado no item 1)

- Log Prefix: cf_meuprojeto (ou qualquer outro prefixo para identificá-los)

- Cookie Logging: off

- Comment: apenas se quiser escrever algo para lembrar

6) Pronto! Agora é só esperar o serviço ir pro ar e testar. Normalmente demora entre 5 a 10 minutos!

Autenticar SSH sem senha

Esse post é mais uma dica que uso há algum tempo, e que algumas pessoas ainda não conhecem. Mas que ajuda muito no dia a dia.

SSH

Antes de mais nada, sabe o que é SSH?

SSH (Secure Shell) é um protocolo para login remoto seguro, ou seja um protocolo que visa fazer a comunicação entre dois hosts distantes através de um autenticação segura e em seguida troca de dados utilizando algoritmos de chave simétrica. Diferente de outras ferramentas como rsh, rcp, rlogin e telnet, o SSH codifica toda a comunicao.

Problema

Uma das coisas mais chatas é ficar acessando ssh e colocar a senha. Principalmente se você tem vários servidores para acessar, e faz isso com muita frequência, ou seja várias vezes ao dia.

Solução

Uma forma de contornar isso é utilizar o:
ssky-keygen e ssh-copy-id

Como Fazer?

Criar as Chaves na máquina local

1) Crie um par de chaves RSA (uma chave privada e uma chave pública) para autenticação, digitando:

 ssh-keygen -t rsa  

2) Será solicitado o local para armazenar a chave.

*Importante: Se você tem várias chaves criadas para cada servidor, é nesse passo que você terá que alterar o nome. Exemplo. Em vez de dar um "ENTER", digite:

 /home/alexandre/.ssh/id_rsa_outroservidor  

3) Será solicitado logo em seguida seu passphrase ou "frase secreta". É uma senha para indentificar que você é o proprietário da chave criada:

*Importante: Guarde essa senha que será usada posteriormente

Após isso sua chave será criada. 2 arquivos serão criados no diretório informado acima:
- id_rsa que é a chave privada
- id_rsa.pub que é a chave pública




Copiar as Chaves para o servidor remoto

Agora será necessário copiar sua chave no servidor remoto:

4) Para fazer a cópia digite:

 ssh-copy-id -i ~/.ssh/id_rsa.pub user@server  

O que ele faz é copiar a chave pública (dá um append) dentro do arquivo "authorized_key". Ou seja ele automatiza esse passo.

5) Será solicitado passphrase (o mesmo que você digitou no passo 3)

6) Pronto! Você já estará acessando seu servidor remoto sem senha. É só testar:

 ssh user@server  

Obs:
Se a chave pública estiver em outro diretório ou você nomeou ele de outra forma passe o parâmetro i:

 ssh -i /home/alexandre/.ssh/id_rsa_outroservidor user@server  







Importante!

Não esqueça de dar as devidas permissões principalmente no servidor que você irá acessar:

chmod 600 /home/servidor/.ssh/authorized_key

chmod 700 /home/servidor/.ssh/




Outras dicas

1) Hostname
Para gerenciar todos os servidores remotos é complicado.
Você pode criar hostname atrelado ao IP, modificando o arquivo:

 sudo vi /etc/hosts  

Colocando IP e depois o hostname.
Assim fica mais fácil lembrar dos servidores.




2) Gerenciador de SSH
Outra dica para não se perder, é usar uma aplicação que é um menu de conexões SSH.

Temos o SSHMenu para GNOME, e achei o Shuttle para Mac.

Ele é simples, pois é só editar um arquivo de configuração (um arquivo Json).

Se tiverem mais dicas, dá uma comentada. Sempre é bom termos opções e saber como outros desenvolvedores trabalham.

CoffeeScript por que não?

Comecei recentemente a usar o CoffeeScript e gostei bastante.

Coffee script from Diego Kurisaki

Resumidamente o CoffeeScript é uma linguagem de script que compila para JavaScript.

A vantagem do CoffeeScript sobre o JavaScript é a inserção de uma série de syntatic sugars e também uma sintaxe mais limpa e concisa que a do JavaScript, por exemplo:

• Blocos através de identação (igual ao Python)
• Retorno implicito de funções
• e etc.

Há uma certa polêmica em torno do CoffeeScript e para mim a mais pertinente de todas se refere ao fato do CoffeeScript introduzir o conceito de Heranças sendo que o JavaScript não funciona assim. Acho que a decisão de se vale ou não a pena usar cabe a você sempre testar e se não gostar tirar.

Um outro ponto é em relação ao código JavaScript que é gerado pelo compilador do CoffeeScript, em muitos casos o código compilado é muito legível e bem "escrito"

Eu ainda tenho dificuldade com o JavaScript e se você é como eu já digo que CoffeScript de jeito algum significa que você deve deixar de tentar aprender o JavaScript.
Muito pelo contrário muitas vezes olhando o código CoffeeScript compilado em Javascript você pode  até mesmo aprender como se faz um bom JavaScript.

Você pode testar mesmo usando o website do CoffeScript, e ainda é possível escrever o código e ver a compilação do javascript no próprio browser.
http://coffeescript.org/

Tutorial do Maven para Android

O Maven é uma ferramenta de gerenciamento de projetos, com ela você pode gerenciar as dependências de seu projeto, automatizar relatórios, execução de testes e etc.

É muito popular em Java mas há também um plugin para usá-lo para gerenciar também um projeto Android.

Pré-requisitos

1. JDK 1.6 +
2. Android SDK
3. Maven 3.0.3 +
4. Eclipse Indigo ou Juno

Primeiramente é necessários configurar a variável de ambiente ANDROID_HOME apontado para o diretório em que está o seu Android SDK, no meu é a seguinte:

export ANDROID_HOME=$HOME/dev/android-sdk

Adicione essa variável em seu path bem como os sub-diretórios $ANDROID_HOME/platform-tools $ANDROID_HOME/tools, exemplo:

export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/tools

Para o Windows seria algo como 

%ANDROID_HOME%\tools e %ANDROID_HOME%\platform-tools

Integração com o Eclipse

Para o Maven para android funcionar bem com o eclipse é necessária a instalação do plugin M2E-Android.

Abra o eclipse e no menu superior escolha Help > Eclipse Marketplace.
Busque por Android M2E.
Clique em Install no item Android Configurator for M2E.
Next, next next e finish...
Reinicie o Eclipse.
Pronto seu plugin já deve estar instalado

Criando um projeto com o Maven

É possível criar um projeto Android pelo maven usando o Eclipse, eu pessoalmente prefiro criar na linha de comando.

mvn archetype:generate \
  -DarchetypeArtifactId=android-release \
  -DarchetypeGroupId=de.akquinet.android.archetypes \
  -DarchetypeVersion=1.0.8 \
  -DgroupId=com.blogspot.runnerdtalks\
  -DartifactId=MavenTest \
  -Dplatform=10 \
  -Dpackage=com.blogspot.runnerdtalks.maventest

Esse archetype gerará um projeto com algumas configurações extras para permitir que o app seja publicado no Google Play.

Ao usar esse archetype serão criados 2 projetos, um chamado MavenTeste para o aplicativo e outro chamado MavenTest-it para os testes do aplicativo criado.
Esse archetype já possui configurações que possibilitam a publicação do aplicativo também no Google Play, ainda existem outros archetypes com menos opções pré configuradas, é possível encontrar esses outros archetypes neste link aqui

Importando o Projeto para dentro do Eclipse.

No eclipse vá em File > Import > Existing Maven Projects escolha o diretório do projeto recém criado e selecione só os dois projetos filhos.

E Finish

Se o projeto estiver reclamando da falta dos diretórios src/test/java crie eles e de um refresh no projeto pelo eclipse.

Para adicionar dependências é só editar seu pom.xml como um projeto Maven normal, depois clique com o botão direito em seu projeto vá em Maven > Update Project.

Lembrando que se um dia precisar compartilhar este projeto com seus amigos ou subir no repositório, sempre remover os arquivos do eclipse e os binários de seu SCM.

Referências

Maven Android Plugin
M2E Android
Android Maven Archetypes

Python

No encontro que tivemos no Utils.runNerdTalks(10), falamos sobre Python.

É difícil falar de uma linguagem, porque tem muita coisa a se falar.

O que posso dizer, é que é a linguagem que mais estou usando ultimamente, e a cada dia descubro coisas novas, e interessantes.

Python 

O Python é uma linguagem de programação de alto nível, interpretada, imperativa, orientada a objetos, de tipagem dinâmica e forte. O código é aberto, e multiplataforma.

Ela foi criada por Guido van Rossum, que não por acaso trabalha hoje na Google (uma das empresas mais conhecidas que utilizam Python).

Apesar do nome estar associado ao réptil píton, a linguagem veio em homenagem ao grupo humorístico britânico Monty Python.


Always Look on the Bright Side of Life

1) Instalação

O Python já vem instalado em vários sistemas operacionais como Linux e Mac. Caso não tenha instalado na máquina acesse aqui.

Hoje ele está na versão 3, mas utilizamos a versão 2.7 para exemplificar. A versão 3 tem quebra de compatibilidade com a versão 2.7

Para verificar a versão do Python na máquina digite:

python --version

2) Começando a brincar

Para abrir um shell interativo, digite

python

Abrirá algo como:

Dentro dele, pode-se digite:

x = 1
y = 1
resultado = x + y
print resultado

Note que diferentemente de Java, nós não atribuimos o tipo para as variáveis. Assim sendo posso também fazer:

x = "Alexandre "
y = "Uehara"
resultado = x + y
print resultado

Isso é o começo para brincarmos com o Python (em um shell interativo). Aliás caso queiram, pode instalar também o iPython (o qual recomendo bastante).

3) Bibliotecas

Para instalar o iPython e outras bibliotecas, recomendo instalar pelo easy_install ou pip. Eles são gerenciadores de bibliotecas (tal como apt-get e RubyGems).

Lembrando que em Python muitas bibliotecas já vem como padrão, não precisando instalar bibliotecas de terceiros.

Exemplo:
Caso eu queira instalar o virtualenv, digite:

sudo easy_install virtualenv

ou

sudo pip install virtualenv

Aliás o virtualenv, é uma ferramenta para termos várias versões de python em sua máquina. Semelhante ao RVM em Ruby.

4) Escrevendo um programa

4.1) Hello World
Para escrever um Hello World, crie um arquivo, helloworld.py
Dentro dele escreva:

print Hello World

Só isso? Sim, só isso. Depois disso, digite no terminal:

python helloworld.py

4.2) Hello World executável
Dentro do mesmo arquivo adicione na primeira linha:

#!/usr/bin/python

Depois dê permissão de executável ao arquivo:

chmod ugoa+x helloworld.py

E, execute:

./helloworld.py

Simples!!!

4.3) Blocos == Identação
O que torna o Python simples de ler, entender e dar manutenção é que não existe blocos com chaves "{" e "}" como no Java. Os blocos são as próprias identações.

 Exemplo: crie um programa chamado:
- nome.py

#!/usr/bin/python
if nome == "Alexandre":
  print nome
else:
  print "outro nome"

Veja que colocamos 2 espaços depois do if, e depois do else. Dê novamente a permissão de executável ao arquivo, e execute.

4.4) Classes 
Apesar da linguagem ser orientada a objetos como vocês puderam ver anteriormente, não precisamos utilizá-lo dessa maneira.

Mas o legal, é realmente usá-lo como OO. Para criar uma classe:

class Empregado()
  def __init__(self, nome):
    self.nome = nome
  def printNome(self, mensagem="Meu nome é: "):
    print mensagem + self.nome

Mas o que é esses montes de "self". É... realmente não é elegante, mas é como se fossem os vários "this" do Java.

E o "__init__"?? É o construtor da classe.

 E o "mensagem=" no método "printNome". O "mensangem=" é o argumento do método, mas com um valor default. Isso é para faciliar a sobrecarga de métodos. Lembrando que não é necessário colocar um valor default para ele..

É possível também passar ao método os argumentos em qualquer ordem, passando o nome do argumento:

#!/usr/bin/python
# -*- coding: utf8 -*-
class Empregado():
  def __init__(self, nome):
    self.nome = nome
  def printNome(self, mensagem="Meu nome é: ", mensagemfinal="."):
    print mensagem + self.nome + mensagemfinal

def main():
  empregado = Empregado("Alexandre")
  empregado.printNome(mensagemfinal="!!!")

if __name__ == "__main__":
    main()

Veja que adicionamos na 2a. linha o encoding.
E para iniciar o programa, colocamos o main.

4.5) Bibliotecas
Para chamar uma biblioteca é só chamar o import:

#!/usr/bin/python
# -*- coding: utf8 -*-
import unittest

ou

#!/usr/bin/python
# -*- coding: utf8 -*-
import os
print os.getcwd()

Veja que acima, nós adicionamos a biblioteca "unittest" e na outra o "os".
Ah! E como dá para perceber, o "unittest" vem como padrão no Python. Muito legal! hahah!!!!

Caso não queira importar tudo, pode-se chamar:

#!/usr/bin/python
# -*- coding: utf8 -*-
from datetime import timedelta
d = timedelta(microseconds=-1)
print d

Importando apenas o timedelta do datetime

4.6) "Grandes poderes trazem grandes responsabilidades."
A linguagem Python deixa você fazer muitas coisas, que outras linguagens não deixam, como acesso a atributos protected.

Ou seja, não é uma linguagem "burocrática", entãããããããão tome cuidado com o que você vai fazer.

Usos da Linguagens

O Python é poderoso. Há muitos tipos de uso como:
- em scripts
- web, usando Frameworks como, Django, Flask, Zope, etc
- CMS, como Plone
- Sistemas embarcados
- Games, usando por exemplo o  PyGame, PyOpenGL
- Jython - Python rodando na JVM
- IronPython - para .NET
- Procesamento de imagens - PIL - Python Imaging Library
- Interfaces Gráficas - PyGTK, PyQt
- etc.

Conclusão

Gostaria de escrever muito mais coisa sobre a linguagem, mas o post já está ficando comprido demais. O que escrevi foi o básico e bem superficial. Abaixo ficará algumas fontes, para quem se interessar mais. Ou entre em contato comigo no @AleUehara

E por último digite no interpretador python:

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Fontes: 

Site Oficial - Python
Python Brasil
Evento Python Brasil
Wikipedia - Python
Django Brasil
Python - Google Groups
Google Python Style Guide
Code Academy
Learn Python

- Livros
Dive into Python
Livros de Python
6 Livros Gratuitos Aprenda a Programar (em pt-br)
Tutorial de Python (em pt-br)

- Curso
Globalcode - Academia Python

- Video
Introducing Python
Show me Do
Python Brasil [5]

- Aplicativo no iPhone
Python for iOS

- Curiosidade
Mandelbrot in Python

Mocks com Mockito - Parte 3

Neste post vamos abordar o uso de Spies usando o Mockito.

Ao contrário de Mocks com os Spies é possível chamar os métodos reais da classe.

List<String> listaSpy = new ArrayList<String>();
listaSpy = Mockito.spy(listaSpy);

listaSpy.add("item1");
//Chama o método verdadeiro do objeto e retorna a String = "item1"
listaSpy.get(0); 

Mockito.doReturn("outra coisa").when(listaSpy).get(0);
//Não chama o método verdadeiro e retorna a String = "outra coisa"
listaSpy.get(0); 

Ao contrário dos Mocks um objeto Spy age como se fosse um Semi mock, em outras palavras,  quando não definimos um outro comportamento para o Spy, seu funcionamento é igual ao de um objeto normal. No entanto ao definirmos um outro comportamento (linha 8) ele se comporta como um Mock para o caso que definimos.

Ok e eu com isso?! Vamos ver um uso mais real de um spy.

O uso que eu tive ao usar o Spy foi para Mockar criação/instanciação de objetos.

Por exemplo, na classe Connection temos o seguinte método.

//declaração da classe Connection
public boolean connect() {
  try {
    socket = new Socket(hostAddress, port);
    printStream = new PrintStream(socket.getOutputStream());
    bufferedReader = new BufferedReader(
                       new InputStreamReader(socket.getInputStream()));
    return true;
  } catch (UnknownHostException e) {
    e.printStackTrace();
  } catch (IOException e) {
    e.printStackTrace();
  }

  return false;
}

public String readMessage() { 
//...
  return bufferedReader.readLine();
//...
}

Como faremos para testar esta classe e o método readLine(), se no cenário atual nós não podemos criar um mock de BufferedReader em nosso teste e passa-la para o objeto Connect, pois o BufferedReader é instanciado dentro da classe Connect!. :/

Spy ao seu resgate! Uma solução é usar Spies para simular isso... então nosso primeiro passo é criar métodos na classe Connect que criem os objetos que precisamos.

Ficando assim o código.

//declaração da classe Connection
public boolean connect() {
  //..
  socket = createSocket();
  printStream = createPrintStream();
  bufferedReader = createInputStream();
  return true;
  //...
}

public String readMessage() { 
  //...
  return bufferedReader.readLine();
  //...
}

protected Socket createSocket() //...
protected PrintStream createPrintStream() //...
protected BufferedReader createInputStream() //...

Veja que os métodos que criam os objetos são protected, isso é necessário pois o Mockito não consegue interceptar métodos que são privados.

O teste da classe ficará assim:

import static org.mockito.Mockito.*;
import static org.junit.Asserts.*;

@Test public void shouldReadMessage() throws UnknownHostException, IOException {
  //cria instancia da classe a ser testada
  Connection connection = new Connection("127.0.0.1", 14000);
  //transforma em um spy
  connection = spy(connection);
  //cria os mocks que serão retornados 
  //pelos metodos de criação de objetos 
  Socket socket = mock(Socket.class);
  BufferedReader bufferedReader = mock(BufferedReader.class);
  PrintStream printStream = mock(PrintStream.class);

  //define o comportamento dos métodos 
  doReturn(socket).when(connection).createSocket();
  doReturn(bufferedReader).when(connection).createInputStream();
  doReturn(printStream).when(connection).createPrintStream();
  when(bufferedReader.readLine()).thenReturn("readed from mock");

  connection.connect();
  assertNotNull(connection.readMessage());
}

Veja que apesar de termos que alterar a nossa classe e extrair as criações de objetos para métodos protected, foi possível criar um teste do método readMessage usando mocks dos objetos do socket.

O uso de Spies da maneira que foi mostrada, pode indicar que seu código esteja com um acoplamento alto e como sempre cabe pensar um pouco se não existe um jeito melhor de programar sua classe para evitar isto.

Isso conclui nossa série de posts sobre o Mockito, pelo menos por enquanto, espero muito que a pequena introdução que escrevi aqui os ajudem a criar seus testes unitários assim como tem me ajudado bastante.

Segue os links que usei de referência
Mocking object creation
Mockito class javadoc
Site do Mockito

Código fonte: https://github.com/diegoy/talks-mockito

Qualquer dúvida, como sempre perguntem, farei o possível para ajudar.

Mocks com Mockito - parte 2

Para continuar nosso "papo" sobre Mocks vou apresentar mais algumas funções do Mockito

Como talvez você já tenha percebido o mockito não serve só para mocks, mas serve também para testar o comportamento da classe que está sob teste com suas dependências.

Usando o mesmo exemplo da nossa classe que envia mensagens. Imagine agora que temos um novo métod que recebe uma ou várias mensagens e as envia usando o objeto connection.

Usando o Mockito podemos escrever um teste como o abaixo.

import static org.mockito.Mockito.*;
//class declaration bla bla bla.
@Test
public void behaviourTest() {
  Connection connection = mock(Connection.class);
  
  MyMessageSender messageSender = new MyMessageSender(connection);
  
  messageSender.sendMultipleMessages("Mensagem 1", "Mensagem 2");
  
  verify(connection, times(2)).sendMessage(anyString());
}

Traduzindo a Linha 11:

• Verificar que o método sendMessage com o argumento...
• uma string qualquer
• foi chamada duas vezes

O Mockito também possibilita simular o retorno de mensagens.

Para demonstrar isto criaremos um novo para sabe se a nossa classe está recebendo as mensagens corretamente, nesse caso ao invés de usar o mock para testar a passagem de parâmetros para ele teremos que usa-lo para simular os retornos de seus métodos.

Testaremos a classe MyMessageReader que se parece com a seguinte classe.

public class MyMessageReader {
  private Connection connection;
  
  public MyMessageReader(Connection connection) {
    this.connection = connection;
  }

  public String readMessage() { 
   return connection.readMessage();
  }
}

Novamente nossa classe sob teste usa um objeto Connection, mas desta vez o método que chamamos é connection.readMessage()

Nosso teste então terá que simular um retorno de connection.readMessage(), usando o Mockito ficaria como o código abaixo.

@Test
public void readMessageTest() {
  connection = mock(Connection.class);
  
  given(connection.readMessage()).willReturn("minhaMensagem");
  myMessageReader = new MyMessageReader(connection);
  
  String readedMessage = myMessageReader.readMessage();
  
  assertEquals(readedMessage, "minhaMensagem");
}

Claro que como tudo em programação existe mais de uma maneira simular os retornos de chamados dos métodos, as duas linhas seguintes são equivalentes.

given(connection.readMessage()).willReturn("minhaMensagem");
when(connection.readMessage()).thenReturn("minhaMensagem");

A primeira linha tem uma abordagem mais em linha com BDD, tanto que o método given é da classe BDDMockito.

Caso o método que simulamos o retorno receba um parâmetro podemos definir diferentes tipos de retorno para diferentes parâmetros, como no exemplo abaixo.

Map map = mock(Map.class);
given(map.get(anyString())).willReturn(null);
given(map.get("chave1")).willReturn("valor1");

map.get("chave1"); //retorna string "valor1"
map.get("outraChave");//retorna nulo

No próximo post de Mocks mostrarei como usar Spies em seus testes com Mock.

Se quiser o código completo pode pegar no git hub.
https://github.com/diegoy/talks-mockito

Valeu!

Mais:
Mocks com Mockito, parte 3

Mocks com Mockito

Desta vez vamos ter uma breve introdução ao uso de Mocks em seus testes.

Há vários benefícios que o uso de testes unitários podem trazer, eu pessoalmente gosto muito de ter testes pois ajuda muito na hora de refatorar seu código e ter a certeza de que o seu funcionamento não mudou, escrever os testes também nos ajuda a identificar casos em que o código está com um alto acoplamento.

Usando TDD ou não os testes são importantes mas podem ser muito difícil de escreve-los

Muitas vezes ao tentar escrever testes para algumas classes temos alguns desafios.
Um Software geralmente depende de vários outros sistemas para funcionar, por exemplo uma base de dados, levando isso em conta os testes de classes que se comunicam com a base de dados são mais difíceis de escrever e o uso de um framework de mocks pode ajudar muito! 

Neste artigo vamos falar do Mockito, que é um framework de mocks criado para a linguagem Java (há versões para outras linguagens). 

A instalação é simples, baixe o jar no site do mockito, coloque-o no seu classpath e pronto! Ou se preferir configure no dependencies de seu maven :)

Suponha que em seu código você tenha uma classe que seja responsável por enviar mensagens através de um socket, aqui vou chama-la de MyMessageSender, sua classe tem como regra enviar mensagens somente com letras maiúsculas.

public class MyMessageSender {
 
  private Connection connection;

  public MyMessageSender(Connection connection) {
    this.connection = connection;
  }

  public void send(String string) {
    connection.sendMessage(string.toUpperCase());
  } 
}

No construtor da classe MyMessageSender passamos como parâmetro um objeto do tipo Connection. Esse objeto possui a conexão do socket e também possui um método sendMessage que escreve uma mensagem no socket.

Para fazer o teste unitário desta classe necessitaríamos instanciar a classe connection para passarmos à classe testada.

 
public class Connection {

  // declaracao dos atributos

  public Connection(String hostAddress, int port) {
    super();
    

    this.hostAddress = hostAddress;
    this.port = port;
  }
 
  public boolean connect() {
    try {
      socket = new Socket(hostAddress, port);
      printStream = getPrintStream(); //abre um output stream
      inputStreamReader = getOutputStream(); //abre um input stream
      return true;
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  
    return false;
  }
 
  public void sendMessage(String message) {
    printStream.print(message);
    printStream.flush();
  }
}

Vendo a classe Connection perceba que será um pouco trabalhoso instancia-la dentro do teste, pois ela se conecta a um sistema externo, levando isso em conta precisaríamos também criar um mock desse sistema externo para testarmos adequadamente a nossa classe. E consequentemente estaríamos testando muito mais que somente nossa classe MyMessageSender.

Usando o Mockito podemos facilmente criar um mock de Connection para usar em nosso teste sem termos que nos preocupar com as conexões que são necessárias a classe Connection.

@Test
public void sendMessageTest() {
 Connection connection = Mockito.mock(Connection.class);
 
 MyMessageSender messageSender = new MyMessageSender(connection);
 
 messageSender.send("Uma mensagem");
 Mockito.verify(connection).sendmessage("UMA MENSAGEM");
}

Na linha 3 criamos um mock da classe Connection.

Na linha 8 colocamos uma verificamos que o método sendmessage do objeto connection foi chamado passando como parâmetro a string "UMA MENSAGEM". Qualquer string diferente da informada na linha do verify vai causar uma falha no teste.

Assim conseguimos garantir o correto funcionamento da classe MyMessageSender sem precisar ficar criando uma instância real da classe Connection.

No próximo post escreverei como o Mockito pode te ajudar para simular respostas de métodos.

Código fonte disponível no meu github
https://github.com/diegoy/talks-mockito

Mais:
Mocks com Mockito, parte 2
Mocks com Mockito, parte 3

Começando com Android

Olá Pessoal, neste post veremos o básico para montar algo em Android.

Para seguir este tutorial você tem que ter na sua máquina.

• Java SDK 5 ou 6 (nunca testei com o 7)
• Android SDK
• Eclipse 3.5 (Galileo) ou mais recente, a versão classic dele basta
• Plugin ADT do Eclipse, plugin de android para eclipse

Caso não tenha nada disso sugiro dar olha olhada neste guia (em ingles) do próprio site do Android. Que aliás será seu maior aliado para desenvolvimento em Android.

Criando seu projeto

Em seu eclipse vá em File>New>Project..., selecione Android Project.

Em Project Name coloque OlaAndroid, clique em Next.

Agora você deve selecionar o Build Target de seu aplicativo, isto definirá a versão mínima que o seu aplicativo poderá ser executado.

Atualmente a mais de 90% dos aparelhos que existentes rodam na versão 2.2 (Froyo) ou superior, a escolha de qual será seu target é uma questão técnica. Existem algumas APIs que só estão disponíveis em versões mais recentes do Android. Um exemplo são os Live Wallpapers, os papéis de paredes animados, só foram introduzidos a partir da versão 2.1, então neste caso você não conseguiria usar um target do android 1.6 para criar Live Wallpapers.

Vale lembrar que apesar de o mais comum é utilizar o número das versões como 2.2, 2.3 ou 3.0 o mais correto no caso do Android é utilizar o API Level. Digo isto pois dentro de uma mesma versão a API pode ter sido mudada.
Por exemplo na versão 2.3 (conhecida também como Gingerbread) existem dois API Levels diferentes. A API Level 9 e 10.

Em developers.android.com você pode verificar as mudanças de cada API com mais detalhes. Neste link você pode ver as mudanças ocorridas na API 10.

Sim isto é bem confuso e se você não entendeu eu tentarei futuramente explicar melhor isto.
Neste projeto vamos escolher a 2.2.

Agora digite o nome do pacote run.nerd.talks.

Diálogo de novo projeto do Android

E aperte finish!

Rodando seu projeto no emulador

Clique com o botão direito em seu projeto selecione Run As > Android Application.

Aparecerá uma imagem avisando que você não possui um dispositivo, selecione Yes para criarmos um emulador do Android.

Na tela acima clique em new, de um nome para seu emulador, neste caso eu dei o nome de Froyo, target 2.2 - API Level 8 e o resto dos campos eu deixei no padrão.
Clique em Create AVD.

Feche as janelas novamente e tente executar o projeto de novo, desta vez o emulador iniciará automaticamente. Você verá algo como a tela abaixo durante um tempo, não se preocupe se demorar pois infelizmente o emulador é muito lento a boa notícia é que você não precisa inicia-lo toda vez que for testar seu aplicativo por isso deixe o aberto.

Emulador iniciando, não se preocupe ele é lerdo mesmo

Depois do emulador iniciar com sucesso ele vai automaticamente abrir seu aplicativo, você verá então algo como o seguinte.

Nosso Projeto rodando \o/

Alterando um pouco o código

Agora vamos dar uma olhada no código já que o próprio plugin do eclipse já se encarregou de criar o famoso Hello World para você.
A estrutura de diretórios no seu projeto deve estar algo como a imagem abaixo.

Vou explicar brevemente cada diretório

• src: é onde você colocará todo seu código fonte Java
• gen: este diretório você não precisará mexer, o próprio Eclipse+ADT se encarrega de gerar o arquivo R.Java nele contido. Explicarei mais adiante o seu conceito
• bin: é o diretório onde o seu projeto compilado ficará
• res: esse diretório é o diretório de resources, imagens, arquivos de localização, sons e layouts ficam dentro deste diretório

Vamos dar uma olhada no código do OlaAndroidActivity.java.

public class OlaAndroidActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Perceba que a classe herda de Activity, uma Activity é um dos elementos mais importantes de um aplicativo Android. Cada activity geralmente representa uma tela que cobre toda a tela do telefone, mas também pode ser um popup que cobre parcialmente a tela.

Veja que nossa Activity OlaAndroid sobrescreve o método onCreate(), este método é um método de Callback da Activity. Os outros são, onRestart(), onStart(), onResume(), onPause(), onStop() e onDestroy(), nós como programadores não temos controle sobre quando esses métodos são chamados e nem podemos impedir que eles aconteçam, todo o ciclo de vida é controlado pelo sistema operacional.

Toda vez que você navega através de seu aplicativo, por exemplo quando você abre a lista de contatos de seu telefone uma activity é executada, quando você seleciona um contato e abre os detalhes dele outra activity é executada e a anterior fica "pausada" mas pode ser até destruída caso o sistema precise de memória.
É importante ter isso em mente ao criar suas Activities.

Na linha 5 veja que é o método equivalente da classe pai é chamado, é importante lembrar que o método da superclasse deve SEMPRE ser chamado antes que você execute qualquer código seu.

Na linha 6 há dois pontos importantes, primeiro está sendo definido qual é o arquivo de layout de sua activity e como parâmetro estamos usando a classe R, esta classe é gerada automaticamente pelo android e se encontra no diretório gen de seu projeto. O R representa todos os resources de seu projeto, desde os layouts até as músicas e os IDs que você declara para os elementos de seu layout você irá acessá-los através do R.
Neste caso estamos definindo que o nossa activity usará o layout main. Vá até o diretório res/layout/main.xml e abra-o.

No canto superior direito veja que tem dois select boxes, um está selecionado como any locale e outro como Android 3.0, mesmo nosso target sendo o 2.2 é preferível usar a renderização do 3.0 pois o preview é melhor que as versões antigas.

Esse editor é no estilo WYSIWYG mas eu particularmente não gosto muito dele, é interessante pois é possível ver os componentes já existentes.
O Android já tem um punhado de componentes prontos que facilitam bastante na hora de criar aplicativos.

Caso, como eu,  prefira criar os layouts digitando o xml na parte inferior clique na aba main.xml.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

</LinearLayout>

Sinto muito dar esta notícia, mas criar layouts em Android não é parecido com nada que eu ou possivelmente você conheça, mas te digo que não é um bicho de sete cabeças, é mais fácil que swing no Java por exemplo :).

Os elementos gráficos no Android são chamado de Views, a classe android.view.View é o elemento básico de componentes gráficos em Android, todas os objetos gráficos são uma subclasse de View

No exemplo atual temos duas views uma chamada LinearLayout e outra chamada TextView

Na linha 2 está a declaração do LinearLayout, LinearLayout é uma subclasse de ViewGroup como o nome sugere uma ViewGroup é um tipo especial de View que tem outras Views como seus "filhos".
Um LinearLayout vai ordenar seus filhos de maneira, pasmem, linear! Pode ser tanto na horizontal android:orientation="horizontal", ou vertical android:orientation="vertical".

Na linha 6 temos outra View agora do tipo TextView, veja que ela está declarada dentro do LinearLayout, um TextView quem diria serve para exibir textos no Android.

O texto a ser exibido por um TextView pode ser definido programaticamente ou descrito no próprio xml usando a propriedade android:text, no código gerado o valor definido é @string/hello, essa é a maneira do android para se fazer a referência para o arquivo de localização, vamos abri-lo segurando o Control (ou command se tiver no mac) e clicando sobre o texto @string/hello, ou se preferir ele está em /res/values/strings.xml.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, OlaAndroidActivity!</string>
    <string name="app_name">OlaAndroid</string>
</resources>

Bom agora acho que fica um pouco mais claro como a macumba, digo mágica acontece. Vamos então ao ...

Mãos a obra! Hands to the work!

Abra novamente o arquivo main.xml

Primeiro vamos alterar o android:layout_width de fill_parent para wrap_content no TextView. Quando este parametro é atribuído com fill_parent a largura da view será igual a largura disponível no pai, se colocar wrap_content a largura será igual a largura do conteúdo da view.

Abaixo dessa TextView vamos adicionar uma View ao nosso Layout, coloque após o TextView um Button

<Button android:id="@+id/helloButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="linha ou coluna"/>

Seu arquivo final ficará assim.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="horizontal" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello" />
    
    <Button android:id="@+id/helloButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="linha ou coluna"/>

</LinearLayout>

Rode o projeto e você vera ele assim.

Vamos alterar agora o android:orientation de vertical para horizontal e executar novamente o projeto, lembre-se não é necessário reiniciar o emulador

E agora seu botão foi colocado ao lado do texto.

Perceba que nosso botão possui um parametro id que está definido com "@+id/helloButton", nossa view agora possui um id helloButton que foi criado automaticamente no R de nosso projeto.

Abra novamente o OlaAndroidActivity.java, se quiser mais uma hotkey aperte [windows = control+shift+r] ou mac [command+shift+r] digite o nome do arquivo e de enter.

Vamos colocar um listener em nosso botão que vai alterar o texto do próprio botão. Sua activity ficará deve ficar como abaixo

private Button helloButton;
private int counter = 0;
 
@Override
public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.main);
 
   helloButton = (Button) findViewById(R.id.helloButton);
   helloButton.setOnClickListener(new OnClickListener() {
      public void onClick(View v) {
         helloButton.setText("clicou "+counter++);
      }
   });
}

Na linha 9 primeiro precisamos da instância do botão que está em nosso layout, para isso usamos o método findViewById passando como parametro o id de nossa view, isso retornará a instância do objeto que está renderizado na tela.

Na linha 10 até a linha 14 implementamos um onClickListener que alterará o texto do botão mostrando um contador de quantas vezes o botão foi apertado

Após apertar o botão seu aplicativo deverá parecer algo com o que está abaixo.

Pronto agora você sabe algumas coisas básicas do Android e poderá se aventurar mais na plataforma, espero que com esse post seja possível ter um apanhado mais básico de como o Android funciona.

Ele acabou ficando maior que eu imaginava e ainda acho que falta muito para explicar, pretendo continuar com essa série de posts sobre android focando em temas mais específicos a partir de agora.

Os sites que mais utilizo como material de referencia e para aprender o Android são os seguintes:
developer.android.com
stackoverflow.com

O código fonte do projeto pode ser encontrado no git hub.
https://github.com/diegoy/OlaAndroid

Obrigado,  se tiverem dúvidas, sugestões de melhoria do post atual ou até temas para próximos posts me avise nos comentários.

Valeu!

Hibernate para iniciantes

Pessoal, neste post vamos demonstrar os passos necessários para utilizar o Hibernate.

O Hibernate é um framework de ORM (Mapeamento objeto-relacional), basicamente é uma maneira de se mapear as tabelas de uma base de dados em objetos no seu programa.

Neste tutorial eu usei o MySQL como base de dados e o Maven para baixar as dependências do projeto, não entrarei em detalhes da instalação do MySQL, sobre o Maven você pode checar o post anterior caso tenha dúvidas.

Primeiramente abra o seu terminal navegue até o diretório onde deseja criar seu projeto e digite o seguinte.

mvn archetype:generate -DgroupId=com.blogspot.runnerdtalks.hibernatetutorial -DartifactId=HibernateTutorial -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Isso irá criar o esqueleto de um projeto Java, dentro do seu diretório HibernateTutorial que foi criado no comando acima você encontrará o seguinte

Agora abra o arquivo pom.xml e vamos adicionar as dependências do hibernate como no trecho abaixo.

<dependencies>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.4.2</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.18</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>3.3.0.SP1</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
   <artifactId>hibernate-annotations</artifactId>
    <version>3.4.0.GA</version>
    </dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>3.4.0.GA</version>
</dependency>
</dependencies>

Volte ao seu terminal de digita o seguinte:

mvn install

mvn eclipse:eclipse

O primeiro comando irá baixar as dependências e o segundo irá criar os arquivos necessários para transforma-lo em um projeto eclipse.

Abra seu Eclipse e vá em File>Import>Existing Projects into Workspace e de Next.
Clique em Browse e navegue até o diretório onde você mandou o Maven criar o seu projeto, e finalize a importação.

Se esta é a primeira vez que você usa o Maven para criar um projeto no Eclipse será necessário resolver alguns problemas no seu Build Path. 

Clique com o botão direito no projeto, e escolha Properties, escolha Java Build Path>Libraries>Add Variable>Configure Variables... > New...

Em Name coloque M2_REPO

Em Path deve ser o caminho do diretório onde o Maven baixa as dependências, isso varia dependendo do sistema operacional que você usa mas, em sistemas como o Linux e OSX é ~/.m2/repository para Windows fica em C:\Document and Settings\username\.m2 (pode variar dependendo da versão do Windows)

Dê ok em todos os diálogos que estavam abertos, caso seu projeto ainda de erros de compilação vá em Projects>Clean... para forçar a recompilação

No diretório src/res o arquivo hibernate.cfg.xml, esse xml é o responsável por configurar para o hibernate o caminho do banco de dados, usuário senha e etc.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>

  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.password">tutorial</property>
  <property name="hibernate.connection.username">username</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernateTutorial</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  <property name="hbm2ddl.auto">create</property>

  <mapping class="com.blogspot.runnerdtalks.hibernatetutorial.entity.User"/>
 </session-factory>
</hibernate-configuration>

Veja que já estamos com uma Entity mapeada, no caso a entity User, deixei ela aí já para nos poupar um passo mas é importante lembrar da necessidade de colocar esse mapeamento no XML.
Lembre-se de fazer as devidas alterações nos campos de conexão, como usuário e senha.

Crie também o arquivo log4j.properties no mesmo diretório como abaixo.

log4j.logger.org.hibernate = info, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

Será necessário colocar os arquivos no seu classpath, clique com o botão direito em seu projeto vá em Properties>Java Build Path>Source>Add Folder... adicione o diretório res e clique em ok.

Agora vamos criar a nossa entity User, como já definimos ela no Hibernate.cfg.xml é importante cria-lá no mesmo pacote: com.blogspot.runnerdtalks.hibernatetutorial.entity


Sua entity vai ficar como a seguinte

package com.blogspot.runnerdtalks.hibernatetutorial.entity;

//imports

@Entity
public class User {

 @Id
 @GeneratedValue
 private Long id; 

 private String name;

 private String password;

 //adicione aqui seus getters e setters

}

Veja que a classe esta anotada com @Entity que identifica que essa é uma Entity do Hibernate, e que temos um membro da classse anotado com @Id e @GeneratedValue

• @ID identifica que ela é a chave primária de sua tabela
• @GeneratedValue é para o próprio hibernate atribuir os valores para ela automaticamente.

Os outros membros não possuem anotação, mas mesmo assim eles serão automagicamente mapeados para colunas na tabela.

Para sua entity isto é o suficiente

Perceba que temos nossa entity mapeada para uma base de dados que não tem nada criado! É porque agora vamos fazer o Hibernate gerar as tabelas da base de dados baseado em nossa entity.

Conecte no mysql com o comando

mysql -u user -p

Dentro do console do mysql vamos criar a base de dados.

create database hibernateTutorial;

Selecione a base de dados recém criada.

use hibernateTutorial

E execute o seguinte para mostrar as tabelas

show tables;

Seu resultado será algo como o seguinte

Crie uma nova classe no pacote com.blogspot.runnerdtalks.hibernatetutorial.main chamada GenerateSchema.

public class GenerateSchema {

    public static void main( String[] args ) {

     //Le o hibernate.cfg.xml

     AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
     annotationConfiguration.configure();

     SchemaExport se = new SchemaExport(annotationConfiguration);
     se.create(true, true);
    }
}

E execute...

O console do eclipse irá mostrar para você diversos detalhes do hibernate se conectando a base de dados e também aparecerá um comando SQL.

Volte ao terminal que você está conectado ao MySQL e execute novamente

show tables;

O resultado deverá mostrar agora a table User, uma tabela não é nada sem dados correto? Então vamos criar uma nova classe chamada CreateNewUser no mesmo pacote do GenerateSchema.

public class CreateNewUser {

 public static void main(String[] args) {

  AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
  annotationConfiguration.configure();

  SessionFactory sessionFactory = annotationConfiguration
    .buildSessionFactory();
  Session session = sessionFactory.openSession();

  User user = new User();
  user.setName("root");
  user.setPassword("raquel");

  Transaction transaction = session.beginTransaction();
  session.save(user);
  transaction.commit();
 }
}

Volte ao MySQL e execute

select * from User;

Seu terminal irá exibir o recém criado usuário na tabela.

Caso tenha percebido que sua tabela esteja sendo recriado toda vez que executa o código é por culpa dessa linha no xml.

<property name="hbm2ddl.auto">create</property>

Comente-a e a execução do código não fará mais sua tabela ser recriada.

Código Fonte no GitHub

Valeu!