Geral

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.

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!

Java x .Net, O UFC Nerd?

Fala pessoal!

Recentemente fui ao evento Java x .Net em São Paulo e foi bem interessante a dinâmica das palestras.

Calma! Antes que você, xiita da programação e defensor assíduo e mortal de uma das plataformas me apedreje, achando que o evento foi uma disputa, vou explicar:

O que não foi o evento? Uma disputa!
O que foi o evento? Discussões inteligentes sobre resolução de problemas nas duas plataformas!

Agora sim você pode largar sua motoserra sossegado!

O evento teve discussões bem interessantes sobre a resolução dos mesmos problemas com as duas plataformas. O evento contou com palestras sobre:
- Cloud computing (com palestra bem interessante do Luciano Condé)
- Dispositivos móveis (com palestra bem interessante do Sérgio Lopes da Caelum)
- JBoss com o pessoal da Red Hat
- Novidades do Java 7 e 8
- Evolução do C#
- E até duas palestras falando sobre o Silverlight 4 e o Flash
- E muito mais!

Figurinhas carimbadas da comunidade estavam presentes, como
Rogério Moraes (organizador do evento, instrutor de cursos oficiais da Microsoft e MVP Microsoft),
Sérgio Lopes da Caelum (Diretor e Instrutor Caelum),
Edgar Silva (Red Hat),
Otávio Pecego (Arquiteto chefe da Microsoft)
Fabiane Nardon (ToolsCloud)
Luciano Condé (Arquiteto de soluções Microsoft)
E muitos outros!

Todas as palestras foram excelentes e com palestrantes de nível técnico altíssimo.
Espero que o Rogério Moraes organize o próximo em São Paulo novamente! :)
Lembrando que, segundo o próprio Rogério, o evento agora terá o “versus” trocado por “&” pra não termos a impressão de disputa.

Vale a pena conferirem o próximo!

Abraços!

Link do site do evento: http://www.javaversusdotnet.com.br/

(mais…)

Começando a jornada…

Fala desenvolvedores!

Primeiro post no blog pra falar qual a idéia da criação do blog e o porquê “perderei” meu tempo escrevendo. E o motivo do blog é bem simples: Ajudar (e ser ajudado) e dar dicas de desenvolvimento, ponto! Sim, simples assim!

Mas por que Alexandre? Simples de novo: senti algumas dificuldades quando comecei a desenvolver e sempre há alguém no mundo que passará (e está passando!) por isso, logo, nada mais justo que ajudar e ser ajudado. Simples assim, again!

A princípio as dicas/tutoriais/discussões serão para os mais iniciantes, mas também espero colaborar com os mais experientes.

E qual a sua idéia Alexandre?

Ensinar a programar Java? Não

Ensinar a programar em Delphi? Não

Ensinar a programar em C? Não

Ensinar Design Patterns? Nao

Ensinar OO? Nao

Ensinar linguagens de baixo nível? Não

Ensinar TDD? Nao

Ensinar DDD? Nao

Ensinar Estruturas de Dados e algoritmos de Grafos? Nao

Ensinar solos de guitarra? Seria bacana, mas Não

(tá bom Alexandre…e que raios você quer então?)

O que quero é simplesmente dar algumas dicas sobre desenvolvimento, sobre boas práticas, sobre projetos nos quais trabalhei como freelancer, como desenvolvedor em software house, dicas em livros que já li, dicas em aulas da USP, dicas em palestras, cursos Caelum, Globalcode, etc.

Algumas dicas serão muito úteis pra uns, tolas pra outros e algumas poderão garantir aquelas infindáveis discussões acaloradas que xiitas da programação adoram fazer! (Seria ótimo!)

É isso! Apesar do meu tempo muito curto pra escrever(tentar) resolvi colocar este primeiro post e quem sabe eu mesmo me cobrar a escrever (novamente tentar!)  sobre o tão adorável, admirável, excitante, poderoso, único (tá bom Alexandre, já entendemos…) mundo do Desenvolvimento de Software.

Abraços pessoal!