Web

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!

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!

Servlets simples e prático, Parte I

Fala Desenvolvedores!!!

Servlets! Nesta série de artigos pretendo falar um pouco sobre os Servlets de uma forma simples e prática e falando também na teoria, que dará uma base melhor quando estiverem nascendo os nossos primeiros códigos com Servlets.

A idéia é também evoluir este assunto para outro assunto bem interessante, o JSP! Vocês verão mais pra frente que, a grosso modo, o JSP é convertido em Servlets.

Tá Alexandre, mas já que os artigos falarão sobre Servlets, nada mais justo que começar o primeiro falando sobre o motivo do nascimento dos Servlets.
Então vamos lá!

O problema!
Como toda boa idéia, os Servlets surgiram justamente a partir de um problema: A necessidade de exibição de páginas geradas dinamicamente na Web.
E por que? Por que no começo tínhamos páginas estáticas, ou seja, páginas muito simples em HTML que não eram capazes de retornar respostas de acordo com as requisições dos usuários.

Resumindo a história: No começo tínhamos diversos servidores que continham diversas páginas HTML estáticas que simplesmente acessávamos seu conteúdo e agora temos páginas que nos respondem dependendo da nossa pergunta, ou seja, capazes de enviar diferentes tipos de respostas dinamicamente.

Solução interessante: CGI
CGI. O Common Gateway Interface (CGI) foi criado justamente para contornar este problema. Qual era a idéia do CGI? Receber a requisição do cliente e gerar páginas web dinamicamente, exatamente como queríamos!Uau! Como? Podíamos escrever programas em CGI que poderiam ser executados a partir de parâmetros passados pelo navegador. Sendo um pouco mais ortodoxo, temos scripts CGI que entendem os parâmetros passados pelo navegador e assim podem enviar uma página web para o navegador criada dinamicamente, de acordo com estes parâmetros.

Exemplo simples: Com CGI podemos fazer uma solicitação via web e um programa CGI pode ler dados de um banco de dados a partir da nossa requisição e devolver uma página HTML com estes dados.

Uma curiosidade é que poderíamos escrever os programas usando por exemplo PHP, C, ASP e Perl.

Mas em Java também temos algo semelhante, os Servlets!

Servlets
Basicamente os Servlets funcionam desta mesma forma: Podem gerar páginas dinamicamente, de acordo com as requisições do usuário.

Os Servlets são da plataforma Java e nada mais são que Classes onde podemos criar objetos e trabalhar com eles, gerando páginas HTML dinamicamente.

Assim, basicamente poderíamos ter o seguinte processo:

Mas já vou te desanimar: Não é uma boa prática trabalharmos gerando páginas HTML diretamente com Servlets!

Você verá nos próximos artigos que trabalhar desta forma é um tanto quanto trabalhoso! No começo estamos felizes e tranquilos com a forma, mas logo percebemos que para algo mais complexo os Servlets tornam a nossa vida mais dura e caótica e não estou exagerando!

E por que saber sobre Servlets então? Por que você pode precisar dar manutenção em algum sistema baseado em Servlets (existem muitos!) e por que temos Frameworks que convertem seus dados em Servlets, como o famoso JSP. Além do mais é bem bacana nós desenvolvedores sabermos com o é o funcionamento por de trás dos Frameworks.

Assim, a grosso modo, o estudo sobre Servlets acaba se tornando um estudo sobre geração de páginas criadas dinamicamente mas em um nível mais baixo.

Servlet Container?
Você pode ter ficado em dúvida sobre o que seria o Servlet Container na figura. Temos um bem famoso e tenho certeza que você já ouviu falar ou usou: O Tomcat! Ele pode ser o nosso Servlet Container para usar os Servlets, ou seja, precisamos de um container para desenvolver com Servlets.

Um Servlet Container pode, por exemplo, gerenciar o ciclo de vida de uma Servlet, dar suporte à segurança, trabalhar com Multithreading, etc. Poderemos detalhar melhor o trabalho de um Servlet Container ao longo dos posts.

Os Servlets trabalham com o conceito de request/response e na figura seria exatamente a requisição específica e resposta específica respectivamente. Apesar de ser bem comum trabalharmos com Servlets com o protocolo HTTP, podemos trabalhar com outros protocolos que seguem este conceito de request/response.

Por que Servlets e não CGI então?
Existem alguns detalhes interessante que nos fazem escolher os Servlets em relação ao CGI, apesar deles terem a mesma idéia de funcionamento.

Segue uma figura com um pequeno comparativo:

Claro que temos outros motivos para o uso do Servlet em relação ao CGI (como serem em Java) e também podemos nos aprofundar nos motivos citados acima. Mas este é um assunto para um futuro post! :)

Finalizando
Pois é, vamos finalizar sem códigos mesmo. Mas fique tranquilo, este post foi apenas para introduzir a idéia sobre Servlets para podermos escrever código sabendo o que estamos fazendo e não simplesmente escrevermos linhas de códigos e esperarmos algum resultado.

Já no próximo post falaremos sobre as Classes que poderemos trabalhar e faremos o nosso pequeno primeiro exemplo! Para provar que trabalhar criando dinamicamente páginas com Servlets não é algo aconselhável e bacana, também faremos outros exemplos mais complexos, para realmente abandonarmos a idéia de trabalhar somente com Servlets, caso esta idéia apareça!

Abraços pessoal!!!