How can I reset the auto increment in MySQL?

Hello Everyone!

This is just a quick post!

We got a problem here where we needed to reset the auto increment field in MySQL Database. It’s easy. You need just run the following command:

ALTER TABLE my_table_name AUTO_INCREMENT = 1;

Right? Not so fast little samurai! I just ran this command and for my surprise it didn’t work.
Why? I removed all my rows before run this command! I was angry!

This happens because we have used this table before and we can’t reset the increment to a value less or equal than a value that has already been used. But this happens only if you are using InnoDB Engine.

To fix it we changed our Table Engine to MyISAM using the following command:

ALTER TABLE my_table_name ENGINE=MyISAM;

After that you can run the the following command and your count will be reset!

ALTER TABLE my_table_name AUTO_INCREMENT = 1

After that we changed again our table to InnoDB Engine : )

That’s it! See you soon!

JPA with Entity Listeners and Callback Methods

Hello Everyone!

Today I’ll talk about Entity Listeners and Callback Methods in JPA Spec!

Callback Methods and Entity Listener in JPA?

Imagine that you’ll save a new blog post in you database using JPA (with Hibernate for example). Sometimes we need to change or put new data in our record before or after it is saved, right? In most cases we need to do that after certain events, like after save our data, before save our data, before delete some record or before update a data.

How can we solve our problem? Maybe most of you like to use Triggers for that. But we have some problems with Triggers. I worked for a company that has used 4 kinds of databases and it was not fun rewrite triggers for all databases. Another problem is you can’t test your code! I like to use TDD in my projects, so I like to test all my business code.

To solve this problem JPA creates a mode that our code can react to certain events, like we talked above. JPA created Callback Methods.
Let’s suppose we have the Post class bellow:

@Entity
public class Post {

   @Id
   private Long id;
   private String title;
   private String text;
   private Date date; //Date? Ok, terrible! Just an example
}

Now we need to persist our post:


public class PostRepository {

    public void save(Post post) {
       entityManager.persist(post);
    }

}

Great! But we need to save our post with a specific date before save it. We can use the @PrePersist annotation:


public class Post {

    @PrePersist
    private void changeDate() {
       this.date = new Date();
    }

}

Nice! Now we have a Callback Method called changeDate that will be executed before persist our object! We have another types of Callback Methods and you can see bellow:

@PrePersist and @PostPersist
@PreUpdate and @PostUpdate
@PreRemove and @PostRemove
@PostLoad

If I have the same callback code for many Entities

Ok! But what if we need to call a Log method (Callback Method) in all of our classes? We will copy the entire code and paste it? It’s not sounds good! For that we can create a specific class with that log code and use it in our classes. We can have our Log class like bellow using @PrePersist:

public class LogListener {

    @PrePersist
    private void log(Object object) {
        System.out.println("Your log code here");
    }

}

Did you note that we received an object? Yes, we receive the object that has being saved at the moment! After that we need to use our LogListener class using the @EntityListeners annotation:

@EntityListeners(LogListener.class)
public class Post {

    @Id
    private Long id;

    private String title;

    private String text;

    private Date date; //Date? Ok, terrible! Just an example

}

Awesome!

Callback Method curiosities

The @EntityListeners allow us to use multiple classes like @EntityListeners({Log.class, Audit.class, YourClass.class}). Nice!

Also, one method can be annotated with more than one Callback annotation:


public class LogListener {

    @PrePersist
    @PreUpdate
    @PostRemove
    private void log(Object object) {
        System.out.println("Your log code here");
    }

}


Can I have two methods annotated with the same callback annotation?

No! You cannot have two methods being annotated by the same callback annotation. See the next code:


public class LogListener {

    @PreUpdate
    @PostRemove
    private void log(Object object) {
        System.out.println("Your log code here");
    }
    @PreUpdate
    private void logAgain(Object object) {
    }
}

The code above is not possible because we have two @PreUpdate annotation and an exception will be throws in our face : )

Can I have two Listener Classes with methods with the same callback annotation?

Sure! You can see that now:


public class LogListener {

    @PrePersist //Log class with PrePersist
    private void log(Object object) {
        System.out.println("Your log code here");
    }

}

 


public class AuditListener {

    @PrePersist //Audit class with PrePersist
    private void audit(Object object) {
        System.out.println("Your audit code here");
    }
}

 

@EntityListeners({LogListener.class, AuditListener.class}) //using both Listeners
public class Post {

    @Id
    private Long id;

    private String title;

    private String text;

    private Date date;

}

After you persist you object you will see the follow:

Your log code here
Your audit code here

Yes, they will be printed following the sequence of the classes in the @EntityListeners.

I love XML! Can I use it?

Sure! You can indicate your callback methods in your persistence.xml

<entity-listeners>
    <entity-listener class="mypackage.LogListener">
         <pre-persist method-name="log"/>
    </entity-listener>
</entity-listeners>

That’s it! See you soon!

Curso SOA na prática – Integração com WebServices e Mensageria

Olá Pessoal!

Como alguns sabem sou Instrutor da Caelum e recentemente tive o prazer de ministrar o novo curso SOA na Prática – Integração com WebServices e Mensageria. Como ficou o curso? Animal!

Já conhecem a Casa do Código não? O sistema como um todo da Casa do Código possui Integrações com outros sistemas que a própria Caelum desenvolveu, como o sistema Financeiro, o sistema de Geração de Ebooks, a própria loja virtual, etc e este grande projeto foi a motivação para este novo curso! Fantástico não?

O curso é basicamente um laboratório prático onde desenvolvemos as Integrações entre os sistemas utilizando coisas divertidas como WebServices (JAX-WS), REST (JAX-RS), ActiveMQ como Broker para a troca de mensagens (Java Message Service), Enterprise Integration Patterns com Apache Camel, além de usar o fresquinho WildFly como Servidor de Aplicação.  JPA aparece de forma mais tímida mas também é mostrada de uma forma bem bacana!

Com um mundo com cada vez mais necessidade de Integrações entre sistemas é fundamental que conheçamos bem este assunto!

Post rápido só pra contar mais essa novidade!

Até mais!

 

 

 

SOLID – Princípio da Responsabilidade Única

Olá Pessoal!

Muito se tem falado sobre boas práticas e bom design de código. Se você gosta de trabalhar profissionalmente no seu código e se gosta de facilitar a manutenção do seu código, com toda certeza já precisou aprender sobre alguns padrões e técnicas para isso.

Muitos destes padrões e técnicas são antigos, datados desde 2000 mas infelizmente ainda encontramos grande parte dos códigos com preocupação alguma de manutenibilidade, facilidade de reuso, com bom desempenho, etc.

Isso me motivou a falar um pouco sobre um dos princípios S.O.L.I.D. Este é um acrônimo para Single responsibility, Open-closed, Liskov substitution, Interface segregation e Dependency inversion. Este termo foi criado por Robert C. Martin(Uncle Bob) para unir alguns padrões muito utilizados no Design Orientado a Objetos, que visam facilitar a manutenção, legibilidade e vida do nosso código.

É quase uma arte desenvolver utilizando alguns desses padrões e com toda certeza a próxima equipe a modificar o seu código(inclusive você mesmo!) vai agradecer.

Hoje falaremos sobre o Single Responsiblity Principle, que é um padrão extremamente simples e muitas vezes absurdamente ignorado. A regra é simples: Uma classe só deve ter uma, e somente uma, razão para ser modificada. Simples assim!

Então isso quer dizer que se eu criar somente um método para a minha classe, com toda certeza ela só terá uma responsabilidade certo? Não é por aí. Na verdade o princípio nos diz o que uma classe deve fazer e não como ela deve fazer. Assim, uma classe poderá ser responsável por uma funcionalidade que pode precisar de 5 métodos para tal realização.

Mas vamos analisar um pequeno código para visualizarmos com mais facilidade este princípio:

public class Departamento {

	public void calculaNotaFiscal() {
		// seu código para calculo da nota fiscal
	}

	public void calculaPagamentoDeFuncionarios() {
		// seu código para cálculo do pagamento
	}

	public void verificaInadimplenciaDeClientes() {
		// seu código para a verificação de inadimplência
	}
}

O que esta classe faz? Bom, ela calcula nota fiscal e calcula pagamento verifica inadimplência. Estes “es” não estão aí atoa. Eles indicam fortemente que a nossa classe tem mais de uma razão para ser modificada, contrariando a nossa simples regra!

Caso o cálculo da nota fiscal precise ser atualizado, modificaremos a classe Departamento. E se o cálculo de pagamento precisar ser melhorado? A classe Departamento também precisará ser modificada.

Observamos aqui que a classe Departamento possui pelo menos 3 motivos para ser modificada e isso não é nada legal. Não será nada divertido modificarmos a classe Departamento toda ver que um requisito for atualizado.

Então para respeitarmos o nosso princípio, poderíamos criar uma classe para cada responsabilidade. Um exemplo seria:

public class NotaFiscal {

	public void calculaNotaFiscal() {
		// seu código para cálculo da nota fiscal
	}

}

 

public class CalculadoraDePagamento {

	public void calculaPagamentoDeFuncionarios() {
		// seu código para cálculo do pagamento
	}

}

 

public class VerificadorDeInadimplencia {

	public void verificaInadimplenciaDeClientes() {
		// seu código para a verificação de inadimplência
	}

}

Agora o nosso código ficou muito mais interessante. Cada classe agora tem uma, e somente uma, razão para ser modificada. Lembrando que cada classe poderá conter quantos métodos forem necessários para que a sua funcionalidade seja satisfeita.

Observe também que com Testes de Unidade você tem uma facilidade muito maior para identificar possíveis quebras do Single Responsibility Principle.

Muitas vezes com um simples princípio e com um simples refactoring conseguimos elevar o nível do nosso código e trabalhar de forma muito mais profissional.

É isso pessoal!

Abraços!

Alexandre Gama.

GitHub e Git – Colaboração e Organização

Olá Pessoal!

Recentemente precisei migrar alguns projetos que utilizavam SVN para o Git e resolvi fazer um post falando um pouquinho sobre o Git e seu amigão GitHub. Então vamos lá!

Git
Hoje dificilmente um projeto não possui um controle de versão. Se o seu projeto de produção não possui um controle de versão, de verdade, corra para criar um! Sobreviver sem um controle é realmente assustador, digno de um herói, ainda mais com equipes grandes e distribuídas.

Durante muito tempo foi usado o CVS e, em seguida, o SVN veio para corrigir algumas falhas do CVS e adicionar interessantes funcionalidades. Diversos são os motivos para a adoção do Git:

- Branches facilitados e independentes
- Merges facilitados (quem já usou CVS sabe o quão sofrível é realizar merges)
- Mais rápido
- Distribuído
- Pode ocupar menos espaço que um checkout SVN
- Integração com o GitHub

Não entrarei em detalhes sobre estes pontos pois renderiam diversos outros artigos, mas entraremos em detalhes sobre a sua instalação logo mais.

GitHub
O GitHub é a rede para programadores. Nele podemos criar repositórios (públicos e privados) para os  nossos projetos, seguir outros desenvolvedores, baixar projetos, modificar projetos, receber atualizações de modificações de projetos, etc.

Diversos projetos grandes já estão no GitHub e você já pode até dar uma olhadinha no código fonte deles! Dentre os projetos encontramos o JQuery, Eclipse, VRaptor, Twitter e muito mais! Abaixo listei alguns repositórios:

- VRaptor
- JQuery
Eclipse

E qual a relação do Git com o GitHub?
A relação é simples: os dois se integram de forma bem simples! Podemos criar um repositório no GitHub e simplesmente “commitar” as alterações do nosso projeto git, tornando-o público!
Como exemplo vamos criar um pequeno projeto e torná-lo público no GitHub, utilizando o Git.

Instalando o Git
Como o meu dia a dia é desenvolvendo com Linux (Ubuntu), faremos a instalação neste ambiente. Vamos lá:

Para a instalação basta abrirmos o terminal e digitar:

sudo apt-get install git-core

Ele mostrará o espaço necessário para a instalação e mostrará quais os pacotes que serão instalados. Basta confirmar que todos os pacotes serão baixados e instalados.
Pronto! Nosso Git está instalado. Agora vamos configurá-lo. Nesta etapa você indicará o seu Nome e o seu Email. Ainda no Terminal digite:

git config --global user.name "Seu nome aqui"
git config --global user.email "seuemail@seudominio.com"

Para verificar se deu tudo certo basta digitar no Terminal:

git config --global --list

Assim serão listadas as configurações recém criadas.

Agora vamos criar um repositório lá no GitHub. Entre no GitHub, entre no seu perfil e clique em New Repository, colocando o nome do seu projeto, no nosso caso “my-first-project-git”. O projeto criado será público mas é possível criar repositórios privados.

Com o nosso repositório criado no GitHub vamos criar o nosso projeto agora localmente. No Terminal vamos criar um diretório para o nosso projeto e iniciar o repositório do Git:

mkdir my-first-project-git
cd my-first-project-git
git init

Agora vamos criar um arquivo Readme e adicionar um repositório ao git. Repare que o origin é apenas um apelido para o nosso projeto.

git remote add origin git@github.com:seuloginnogithub/my-first-project-git.git
touch  README

Tudo certo até aqui. Criamos o nosso projeto no GitHub, criamos o nosso projeto localmente com o Git e agora vamos subir o nosso projeto para o GitHub. Mas antes de subirmos o projeto, precisamos gerar uma chave ssh. Podemos gerar uma chave com o seguinte comando no Terminal:

ssh-keygen -t rsa -C "seu comentario"

Ele mostrará o diretório onde será salva a nossa chave e você também informará uma senha. Pronto! Chave criada! Agora precisamos acessar a nossa conta no GitHub, clicar em SSH Keys e inserir o conteúdo exato que foi gerado na chave. Para pegar o conteúdo basta digitar o seguinte comando:

cat ~/.ssh/id_rsa.pub

Desta forma já podemos acessar o nosso GitHub!

Para adicionar o nosso arquivo Readme e “comitá-lo” basta digitarmos os seguintes comandos:

git add README
git commit -m "aqui vai seu comentario"

Repare que neste momento fizemos o commit localmente mas ainda não enviamos para o GitHub. Para enviar basta digitar o seguinte comando:

git push -u origin master

Pronto! Agora você pode acessar o seu GitHub e ver o projeto que acabamos de criar. Simples, prático e divertido!

No próximo artigo avançaremos sobre os comandos mais utilizados pelo Git e como podemos modificar projetos já existentes no GitHub.

Não poderei disponibilizar os projetos privados mas disponibilizarei alguns outros projetos públicos no meu GitHub para podermos compartilhar conhecimento e experiência. Podem seguir =)

Até mais!

JSON Simples e Prático, Parte II

Fala pessoal!

Seguindo a ideia do post anterior sobre JSON, hoje vamos a um exemplo mais palpável, real e divertido: Simular uma integração com o famoso Facebook!

O Facebook, assim como diversos sistemas, disponibiliza acesso aos seus recursos através de alguns métodos. A este conjunto de métodos, damos o nome de API.
Como visto no artigo anterior, JSON é um documento com uma estrutura bem bacana de se trabalhar.

Veja o JSON que o Facebook retorna quando chamamos certo método:

{
   "id": "19292868552",
   "name": "Facebook Platform",
   "likes": 4190683,
   "category": "Product/service",
   "is_published": true,
   "website": "http://developers.facebook.com",
   "username": "platform",
   "founded": "2007",
   "mission": "To make the web more open and social.",
   "talking_about_count": 98577
}

Interessante não? Muito fácil de ler e encontrar os dados que precisamos. Temos o id, name, likes e muitas outras informações.

Agora imagine que a nossa aplicação precisa buscar os dados de um post específico que foi colocado no Facebook. Podemos imaginar também que precisaríamos persistir esses dados em um banco pra futuras comparações, pesquisas, etc.

No nosso caso usaremos este post para estudo: www.facebook.com/98423808305.

Nao vou prolongar sobre a API do Facebook, mas para usá-la podemos usar o Graph API que o Facebook disponibiliza. Aqui temos o core da API, onde podemos ter diversos métodos para as diversas chamadas que precisamos. Caso você precise desenvolver uma app para o Face, este será o local mais odiado visitado por você! = )

Agora que você já sabe sobre a existência do Graph API, vamos usá-la!

Para o nosso exemplo vamos usar a seguinte URL:
https://graph.facebook.com/98423808305

Repare que ao clicar na URL, já temos o retorno em JSON! Isso mesmo, simples assim! Para o nosso projeto vamos precisar do Id e dos dados do From (Name e Category).

A primeira classe que criaremos é muito simples, somente para conseguirmos fazer uma chamada GET na url acima e receber o seu retorno.


package br.com.artigo.json;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;

public class Http {

    public String chamaUrl(String url) throws IOException {
      URL facebook = new URL(url);
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(facebook.openStream()));

      String retornoJson;

      StringBuilder builder = new StringBuilder();
      while ((retornoJson = bufferedReader.readLine()) != null)
        builder.append(retornoJson);

      bufferedReader.close();

      return builder.toString();
    }
}

A segunda classe criada será um POJO que conterá as informações que precisamos (id, name e category) vindas do facebook. Repare que esta classe facilmente poderia ser persistida, bastando inserir as anotações do JPA por exemplo! = )

package br.com.artigo.json;

public class Facebook {

	private String id;

	private String name;

	private String category;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCategory() {
		return category;
	}

	public void setCategory(String category) {
		this.category = category;
	}

	@Override
	public String toString() {
		return "Facebook [id=" + id + ", name=" + name + ", category="
				+ category + "]";
	}

}

A terceira classe é a ArtigoJson que será a classe principal. Ela usará a classe Http para fazer a chamada simples da API e trabalhará com o retorno JSON.

package br.com.artigo.json;

import java.io.IOException;
import java.util.Map;
import net.sf.json.JSONObject;

public class ArtigoJson {

	private static final String HTTPS_GRAPH_FACEBOOK = "https://graph.facebook.com/98423808305";

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws IOException {
		//Retorno JSON
		JSONObject object = chamadaHttp();
		System.out.println(object);

		//Retorno dos dados que precisamos
		String id = (String) object.get("id");
		Map map = (Map) object.get("from"); //Que interessante! Um cast para um Map!
		String name = map.get("name");
		String category = map.get("category");

		//Populando o objeto facebook para persistencia
		Facebook facebook = new Facebook();
		facebook.setId(id);
		facebook.setName(name);
		facebook.setCategory(category);

		//Impressão do objeto
		System.out.println(facebook);
	}

	private static JSONObject chamadaHttp() throws IOException {
		Http http = new Http();
		String retornoJson = http.chamaUrl(HTTPS_GRAPH_FACEBOOK);
		JSONObject objetoJson = JSONObject.fromObject(retornoJson);

		return objetoJson;
	}
}

Ao fazer a chamada, podemos ver um trecho do retorno:

{"id":"98423808305",
   "from":
      {"name":"Coca-Cola","category":"Food/beverages","id":"40796308305"}
}

Olha que simples! Temos neste trecho as informações que precisamos! = )
Como no artigo anterior, podemos fazer uma chamada usando uma chave. Repare que fizemos a primeira chamada usando a chave id:

//Retorno dos dados que precisamos
String id = (String) object.get("id");

Mas o mais interessante nas chamadas é o cast para um Map!

Map map = (Map) object.get("from");

Agora podemos obter os nossos dados pelo próprio Map e popular o nosso objeto facebook!

É isso pessoal! Artigo bem simples para o pessoal que está começando, somente pra mostrar uma das formas de utilização do JSON.

Você também pode encontrar este código no meu Gist Público.

Até mais!

JSON Simples e Prático, Parte I

Fala pessoal!

Esta semana percebi que muitos ainda não conhecem ou continuam na dúvida sobre o que é JSON e resolvi contribuir com mais um artigo.

Afinal, o que é JSON?
JSON é basicamente um formato leve de troca de informações/dados entre sistemas. Mas JSON significa JavaScript Object Notation, ou seja, só posso usar com JavaScript correto? Na verdade não e alguns ainda caem nesta armadilha.

O JSON além de ser um formato leve para troca de dados é também muito simples de ler. Mas quando dizemos que algo é simples, é interessante compará-lo com algo mais complexo para entendermos tal simplicidade não é? Neste caso podemos comparar o JSON com o formato XML.

Vamos visualizar esta diferença?

  <?xml version="1.0" encoding="UTF-8"?>
    <id>1</id>
    <nome>Alexandre Gama</nome>
    <endereco>R. Qualquer</endereco>
  {"id":1,"nome":"Alexandre Gama", "endereco":"R. Qualquer"}

Bom, é notável a diferença. Visualmente o segundo trecho (em JSON) é mais fácil de ler. Mas só existe essa diferença entre os dois? Na verdade não. Podemos listar algumas outras vantagens:

Vantagens do JSON:
- Leitura mais simples

- Analisador(parsing) mais fácil

- JSON suporta objetos! Sim, ele é tipado!

- Velocidade maior na execução e transporte de dados

- Arquivo com tamanho reduzido

- Quem utiliza? Google, Facebook, Yahoo!, Twitter…

Estas são algumas das vantagens apresentadas pelo JSON. Agora vamos ao que interessa: Código! :)
Vamos fazer um exemplo extremamente simples nesta primeira parte e avançaremos no próximo artigo, inclusive falando sobre JSON em páginas Web.

Qual biblioteca usar?
Existem diversas bibliotecas para trabalharmos com JSON e Java. Usaremos no nosso estudo o json.jar que você pode baixar tranquilamente neste link

O nosso caso de estudo será simples: Teremos uma classe Carro que será a nossa classe POJO e a classe EstudoJSON que terá o nosso famoso método main.

Classe Carro

package br.com.json;

public class Carro {
	private Long id;
	private String modelo;
	private String placa;

	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getModelo() {
		return modelo;
	}
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}
	public String getPlaca() {
		return placa;
	}
	public void setPlaca(String placa) {
		this.placa = placa;
	}

        //Aqui fizemos o Override do método toString() para visualizar a impressão com o System.out.println()
	@Override
	public String toString() {
		return "[id=" + id + ", modelo=" + modelo + ", placa=" + placa
				+ "]";
	}

}

Esta é uma classe simples, onde temos os atributos Id, Modelo e Placa.

Agora teremos a classe EstudoJSON

package br.com.json;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class EstudoJSON {
	public static void main(String[] args) throws JSONException {
		adicaoSimplesDeDados();
	}
}

Repare que criamos o método adicaoSimplesDeDados() que conterá o código de exemplo:

private static void adicaoSimplesDeDados() throws JSONException {
    //Criação do objeto carro e atribuição dos valores
	Carro carro = new Carro();
	carro.setId(1l);
	carro.setModelo("Celta");
	carro.setPlaca("AAA1234");

    //Criação do objeto carroJson
	JSONObject carroJson = new JSONObject();
    //Inserção dos valores do carro no objeto JSON
	carroJson.put("id", carro.getId());
	carroJson.put("Modelo", carro.getModelo());
	carroJson.put("Placa", carro.getPlaca());

    //Impressão do objeto JSON
	System.out.println(carroJson);
}

Se executarmos este código, veremos que foi impresso no console o seguinte:

{"id":1,"Modelo":"Celta","Placa":"AAA1234"}

Você desenvolvedor mais atento vai reparar que existe um objeto impresso: Um Long! Isso mesmo! Como vimos, o JSON consegue armazenar objetos! Podemos inclusive armazenar um objeto do tipo Carro mesmo:

Modificamos o nosso método main:

public class EstudoJSON {
	public static void main(String[] args) throws JSONException {
		adicaoSimplesDeDados();

        adicaoDeUmObjeto();
	}
}

E adicionamos o método adicaoDeUmObjeto():

private static void adicaoDeUmObjeto() throws JSONException {
	Carro carro = new Carro();
	carro.setId(1l);
	carro.setModelo("Celta");
	carro.setPlaca("AAA1234");

	JSONObject carroJson = new JSONObject();
    //Adição do objeto carro
	carroJson.put("Carro", carro);

	System.out.println(carroJson);
}

Neste caso foi impresso no console o seguinte:

{"Carro":"[id=1, modelo=Celta, placa=AAA1234]"}

Simples não?
Como o JSON trabalha com coleção de pares nome/valor, podemos imprimir um valor específico simplesmente chamando o nome que desejamos.

System.out.println(carroJson.get("Modelo"));

Veja que neste caso queremos somente o modelo do carro, bastando fazer a chamada get(“nome que desejamos”)!

Conclusão
É isso pessoal! Vimos as vantagens do JSON e vimos como é simples começar a trabalhar com ele. Nos próximos artigos veremos exemplos mais complexos e veremos algo mais real onde faremos chamadas à API do Facebook!

Você também pode encontrar este código no meu Gist Público.

Abraços!

Voltando ao Blog!

Fala pessoal!

Pois é! Fiquei um bom tempo longe, muito longe do blog devido aos milhares de compromissos. Este é um total quick post  só pra avisar que o blog não morreu e que estou voltando a escrever neste fim de ano e que pretendo escrever sobre diversos assuntos, principalmente as Tecnolgias, Frameworks, Bibliotecas, Linguagens, etc que vim trabalhando ao longo deste ano.

Dentre os vários assuntos estarão
Java,
Ruby,
PHP,
Tuning de banco,
NoSQL,
JavaScript,
HTML 5,
JQuery,
VRaptor,
JSF,
JPA,
TDD,
BDD,
Padrões de Projetos,
Cloud Computing
e muito mais!! Também farei overviews, críticas e sugestões dos eventos que participarei para podermos trocar mais informações ainda! =)

É isso pessoal, um simples aviso e espero contar com a ajuda de todos para termos artigos de qualidade! =)

Abraços!

MVC simples e prático, Parte I

Fala pessoal!

Sim, assunto batido! Model View Controller! Mas é muito comum encontrarmos pela internet tutoriais um pouco estranhos, visões às vezes que parecem particulares, diagramas errados e alguns ainda com dúvidas.

O conceito do MVC é extremamente simples mas a sua visualização não é lá tão trivial assim. O artigo tem 2 objetivos principais: Relembrar a teoria e mostrar uma visualização simplificada do conceito.

Então vamos lá!

Entendendo o papel do M – Model

Pessoal, a idéia é simples: Quando pensamos em regras de negócio, estamos pensando no Modelo da aplicação. Basicamente é isto. No Model podemos ter validações, acesso a banco, acesso à arquivos, cálculos, etc.

O usuário, por exemplo, coloca um produto em um carrinho de compras e é no Model que faremos o cálculo final do pedido(descontos, juros), que validaremos a conta do usuário, que calcularemos o frete, que validaremos o endereço e por aí vai.

Mas como o usuário seleciona um produto em um carrinho de compras por exemplo? Como insere um Endereço para a entrega? Na View!

Entendendo o papel do V – View

A View só existe por um único motivo: Mostrar dados! Na prática isso nunca muitas vezes não acontece, mas deveria! Você que já desenvolveu em Delphi/VB com toda certeza já viu regras em um botão. Você que já desenvolveu em Java também já viu centenas de regras nas páginas JSP ou espalhadas em Servlets que criam as páginas. Isso é feio! O dia que precisarmos mudar de JSP para JSF ou GWT simplesmente não mudaremos!

Mas e agora? Entendido o conceito básico do Model, como a View passa os valores digitados/selecionados para o Model? Passa direto? Não!

Entendendo o papel do C – Controller

Aqui temos um maestro! Temos regras de negócio no Controller? Não! Temos visualização no Controller? Não! O Controller simplesmente delega para o Model as solicitações da View. O Controller é burro no sentido de regras de negócio da aplicação. Ele é responsável por saber quem está pedindo algo e a quem enviará este algo!

O Controller conhece a View e conhece o Model mas o Model não conhece a View, porém a View observa o Model e este avisa quando seus dados foram atualizados, para a View mostrá-los.

Ok! Depois dessa frase bagunçada, nada como um pequeno esquema para entendermos melhor:

Diagrama MVC

Entendendo o MVC

Veja como é simples com o diagrama acima:

O Controller conhece a View e conhece o Model. Isto porque ele recebe as requisições do usuário da View e envia para o Model fazer algo com estas requisições. Exemplo: O usuário quer saber o endereço de uma residência a partir de um cep digitado.

O Model simplesmente recebe a requisição, faz toda a mágica (persiste dados, valida informações, etc) e fica com os dados prontos (atualizados) para serem visualizados novamente pela View.

A View fica observando o Model e quando este é atualizado, a View mostra os dados atualizados para o usuário.

E o Model acaba não conhecendo ninguém!

Legal! E por que eu trabalharia desta forma?

Porque, além de elegante, é profissional! Mas se você não se convenceu com estes argumentos, podemos ter outro: é Seguro! Temos aqui uma separação bem clara entre a Visualização e as Regras de Negócio. Caso você queira modificar uma regra, como um cálculo de juros, você precisaria apenas modificar o seu Model (e espero que em um só local! =) )  e não precisaria se preocupar com a visualização.

O mesmo vale para a View. Caso você queira modificar uma tela inteira, não precisaria se preocupar com as regras e sim somente com a tela.

Um outro motivo muito forte é que você pode querer disponibilizar os seus métodos em um WebService por exemplo e com uma separação clara do seu modelo, isso seria facilitado, e muito! Imagine que você tenha uma aplicação Web e outra Desktop (JSF e Swing por exemplo) mas que façam a mesma coisa. Seria muito ruim ter funcionalidades iguais nos dois ambientes pois teríamos que manter as duas iguais. Uma forma seria disponibilizar as funcionalidades em um ponto único e acessá-las nas duas aplicações. Com uma separação clara do modelo poderíamos disponibilizar estas funcionalidades por um WebService, Rest, EJB, etc.

Finalizando

O MVC é um padrão de arquitetura que existe, a grosso modo, para facilitar a manutenção da nossa aplicação, facilitar a adição de funcionalidades e facilitar a testabilidade da aplicação.

Se você ainda escreve regras de negócio nas suas páginas/forms, tente desenvolver com este padrão e veja a diferença na manutenção e na adição de funcionalidades.

No próximo post veremos um exemplo simples de implementação de uma funcionalidade utilizando o padrão MVC e veremos como é simples melhorarmos a nossa aplicação deixando-a profissional.

É isso pessoal! Abraços!

Algoritmos, Parte II – Primeiros códigos

Fala pessoal!

Idéia
Neste artigo continuaremos a série sobre Algoritmos! No primeiro artigo resolvemos 3 problemas bem simples, utilizando a idéia de pseudocódigo, onde podemos visualizar melhor os passos para a resolução de um problema e não precisamos conhecer nenhuma linguagem de programação nesta etapa.
Neste segundo artigo vamos resolver o primeiro problema apresentado anteriormente, já utilizando Java e C.

Pra você que está iniciando os estudos e não conhece muito bem a sintaxe das linguagens não se preocupe pois a idéia desta série é mostrar os passos para a resolução de um problema e vamos usar essas linguagens só para os problemas não ficarem tão vagos!
Vamos lá!

Quebrando em pequenos pedaços
Conforme havia dito no artigo anterior, podemos dividir um problema em passos para chegar na sua resolução final. A idéia de divisão de um problema em problemas menores já é antiga e facilita muito a nossa vida, pois podemos pensar na resolução de “mini-problemas”, deixando de lado a visão macro do problema. Após a resolução dos pequenos problemas, o problema maior é resolvido através da união destes.

Primeira resolução
Para o nosso primeiro código, vamos atacar o problema 1 do artigo anterior. Vamos lembrá-lo:
“Problema: Fazer a divisão de um número por outro. Se o resultado for positivo, imprimir o número encontrado pela divisão, caso seja negativo, imprimir zero. Caso o divisor seja zero, imprimir o valor -1.”

No artigo anterior também vimos a resolução deste problema através de um fluxograma e também criamos um pseudocódigo com a intenção de fazer qualquer pessoa entender o objetivo que gostaríamos de atingir, que é a resolução do problema acima.

Ambiente
Com o problema em mãos, vamos fazer o passo a passo da resolução já utilizando as duas linguagens citadas, pra que possamos visualizar o fluxo em um nível mais baixo.
Para o Java, utilizarei o Eclipse e para o C utilizarei o DevC++. Particularmente não gosto do DevC++ e uso o GCC do Ubuntu, mas o DevC++ é bem utilizado pelos que estão começando. O Eclipse talvez não seja o mais usado pelos iniciantes (o comum é usarem editores simples) , mas ele é muito conhecido. Fique à vontade para desenvolver no NetBeans, JCreator, JBuilder, etc.

Relembrando
Esqueça a sintaxe do código abaixo caso você não a entenda agora. O ponto forte aqui pra você que está começando é entender o conceito, a lógica, a idéia. Pense na situação simples: Pra você pedir um cafezinho, você segue alguns passos, como encontrar um local, chamar o garçom, escolher o café, ver o preço e pedir. E você vai fazer exatamente a mesma coisa se estiver no Brasil, Japão ou na África e só vai mudar o idioma, a “sintaxe”!
Portanto, entender os passos neste momento é muito mais útil e fundamental que entender a sintaxe, a linguagem.

Primeiro código em Java
Vamos criar o nosso primeiro código em Java. Para isso, vamos criar uma classe com o nome de “DivisaoDeNumeros“. Esta é a classe que irá conter a nossa lógica para a resolução do problema. Com a classe criada, vamos criar o método “main” para podermos executar a aplicação, ou seja, imprimir os dados.

//Classe que trata das divisões de números
public class DivisaoDeNumeros {
    public static void main(String[] args) {

    }
}

Agora com a classe e o método principal criados, vamos fazer o passo a passo do artigo anterior, porém escrevendo em código! Pra não ficar uma leitura muita cansativa e demorada fazendo cada passo, escrevi o código inteiro e comentei cada passo no próprio código.

public class DivisaoDeNumeros {

	public static void main(String[] args) {
		//Criamos um objeto Scanner para capturar o que foi digitado
		Scanner input = new Scanner(System.in);
		//Imprime mensagem para a inserção do primeiro valor
		System.out.println("Insira o valor do dividendo: ");
		//Guarda o valor digitado pelo usuário na variável dividendo
		int dividendo = input.nextInt();
		//Imprime mensagem para a inserção do segundo valor
		System.out.println("Insira o valor do divisor: ");
		//Guarda o valor digitado pelo usuário na variável divisor
		int divisor = input.nextInt();

		//Verifica se o valor do divisor é igual a zero
		if (divisor == 0) {
			//Imprime o valor -1 caso o divisor seja zero
			System.out.println("-1");
		}
		//Verifica se o valor do cálculo da divisão é negativo
		else if ((dividendo / divisor < 0)) {
			//Imprime o valor 0 caso o resultdo da divisão seja negativo
			System.out.println("Valor encontrado: 0");
		}
		else {
			//Como o divisor não é zero e o cálculo não é negativo, imprime o resultado da divisão
			System.out.println("Valor calculado: " + dividendo / divisor);
		}
	}
}

Você pode perceber que a execução está bem simples! Pelos comentários, podemos ver que passamos pelo “passo a passo” do artigo anterior, mas desta vez não escrevemos um pseudocódigo e sim um código em Java que podemos executar. Se você não está acostumado com a sintaxe, perceba que não foi difícil de entender o conceito, a idéia por de trás do código.

Esta é uma possível solução do problema, e não única. Podemos ter outros passos pra resolução! Mas será que se só trocarmos as condições (if’s / else if’s) teremos o mesmo resultado? Que tal tentar dar uma olhada no código abaixo e ver qual o problema?

import java.util.Scanner;

public class DivisaoDeNumeros {

	public static void main(String[] args) {
		//Criamos um objeto Scanner para capturar o que foi digitado
		Scanner input = new Scanner(System.in);
		//Imprime mensagem para a inserção do primeiro valor
		System.out.println("Insira o valor do dividendo: ");
		//Guarda o valor digitado pelo usuário na variável dividendo
		int dividendo = input.nextInt();
		//Imprime mensagem para a inserção do segundo valor
		System.out.println("Insira o valor do divisor: ");
		//Guarda o valor digitado pelo usuário na variável divisor
		int divisor = input.nextInt();

		//Verifica se o valor do cálculo da divisão é negativo
		if ((dividendo / divisor < 0)) {
                        //Imprime o valor 0 caso o resultdo da divisão seja negativo 
                        System.out.println("Valor encontrado: 0");
                }
                //Verifica se o cálculo é positivo
                else if (dividendo / divisor > 0) {
			//Imprime o resultado do cálculo caso o resultado seja positivo
			System.out.println("Valor calculado: " + dividendo / divisor);
		}
		//Como o resultado não é positivo e nem negativo, podemos supor que o divisor é zero
		else {
			//Imprime o valor -1 pois o divisor é zero
			System.out.println("-1");
		}
	}
}

Erro! Veja como não precisamos entender a linguagem/sintaxe pra saber que este código terá problemas. Se olharmos com mais “carinho” vamos perceber que o código, na primeira condição, já tenta calcular a expressão. Se você inserir o valor zero para o divisor, teremos um erro no caso do Java que é o “java.lang.ArithmeticException: / by zero”, ou seja, não existe divisão por zero matematicamente falando e claro que na execução o Java vai reclamar.

Perceba que na resolução não basta simplesmente trocarmos as condições. Os passos para a resolução de um problema devem ser bem definidos e bem pensados para que nenhuma regra seja violada.

Código em C
Abaixo temos o código em C, que é muito usado nos cursos de introdução à computação.

#include<stdio.h>
#include<stdlib.h>

int main() {
   //Declaração das variáveis para guardar os valores
   int dividendo;
   int divisor;

   //Imprime mensagem para a inserção do primeiro valor
   printf("Digite o valor do dividendo:");
   //Guarda o valor digitado pelo usuário na variável dividendo
   scanf("%d", &dividendo);

   //Imprime mensagem para a inserção do segundo valor
   printf("\nDigite o valor do divisor:");
   //Guarda o valor digitado pelo usuário na variável divisor
   scanf("%d", &divisor);   

   //Verifica se o valor do divisor é igual a zero
   if (divisor == 0) {
      //Imprime o valor -1 caso o divisor seja zero
      printf("-1\n");
   }
   //Verifica se o valor do cálculo da divisão é negativo
   else if ((dividendo / divisor < 0)) {
      //Imprime o valor 0 caso o resultdo da divisão seja negativo
      printf("Valor encontrado: 0\n");
   }
   else {
      //Como o divisor não é zero e o cálculo não é negativo, imprime o resultado da divisão
      printf("Valor calculado: %d \n", (dividendo / divisor));
   }
   //Pausa a execução
   system("PAUSE");
}

Entendimento do conceito x Sintaxe da linguagem
Volto a lembrar que não foi preciso entender 100% a sintaxe para entender o que está acontecendo. Nos comentários do código vimos o “passo a passo” para a resolução do algoritmos e basicamente traduzimos logo em seguida para a sintaxe utilizada no Java e no C.
Devemos lembrar também que não existe somente um passo para a resolução do problema e você pode ficar à vontade pra modificar os códigos acima, criando outros passos!

Finalizando
Neste artigo vimos a resolução de um problema usando Java e C e a idéia principal é entender o conceito! Entendido o problema e os passos para a resolução dele, traduzí-lo para a linguagem é o “mais fácil”. Podemos entender muito de uma linguagem, mas se não conseguirmos resolver um problema com passos bem definidos, não conseguimos fazer nada.

Nos próximos artigos desta série vamos resolver alguns problemas mais complicados (este foi bem simples, apenas para a introdução) e em breve vou falar sobre assuntos mais específicos, como Pilhas, Filas, Tempo de Algoritmo, etc.

Estes códigos você também pode encontrar em:
Código em Java
Código em C

Abraços!!!