29 dezembro 2008

CodeInfo: plug-in para contagem em código na plataforma Eclipse.

Este é o meu segundo projeto open source (o primeiro foi o TCC https://sourceforge.net/projects/erpoo), feito sem nenhuma pretensão de grandeza, ou de se equiparar aos grandes plug-ins cheios de recursos do mundo eclipse. Porém para quem gosta de informações focadas e leveza, este é pode ser uma boa opção.

Seguem as features:

Autor

* Cleuber Batista Silva – cleuber_s@hotmail.com

Versão
Alfa 0.1

Dependências

Plug-in : org.eclipse.jdt.core
Eclipse: 3.3

Instalação e Uso

O Eclipse possui um componente chamado Platform Runtime (responsável pela descoberta de novos plug-ins). Toda vez que a plataforma é inicializada, este componente varre o diretório plugins do local em que o Eclipse está instalado. Desta forma para realizar a instalação de um novo plug-in basta colocá-lo neste diretório.

A exibição de informações sobre o código é feita, clicando-se sobre o menu CodeInfo, e será exibido o total de pacotes usados, total de classes, interfaces e classes abstratas; além do total de linhas (somatório de todos os arquivos com extensão .java) e a média aritmética de linhas por arquivo.


Onde Baixar?
Projeto: https://sourceforge.net/projects/codeinfo
Download : https://sourceforge.net/project/showfiles.php?group_id=248547

Aguardo críticas !

18 dezembro 2008

Pentaho: uma plataforma de Bussiness Inteligence Open Source


Durante algum tempo estive pesquisando uma solução em Bussiness Inteligence que fosse Open Source. As ferramentas do mercado, atualmente, são caríssimas não estando na realidade de empresas de porte.

Foi aí que me deparei com o Pentaho que é na verdade uma plataforma de soluções, que possui recursos como relatórios, análise, integração de workflow, regras de negócios, auditoria, interface e análise/modelagem de workflow.

Para quem se interessou pelo mesmo, pode conferir neste link uma simples versão de demonstração de um datawarehouse com dados fictícios: http://demo.pentaho.com/pentaho

Sumário das Vantagens do Pentaho

Usabilidade - A plataforma BI tem componentes prontos para serem executados, é de fácil integração com sistemas externos, e oferece interfaces de fácil customização. Isto resulta em soluções que são muito fáceis de serem usadas.
Habilidades - A plataforma de BI utiliza reconhecidos padrões, de maneira a facilitar a utilização de ferramentas de parceiros.
Customização - A plataforma de BI tem mecanismos externos de regras, processos editáveis, disponibilidade de códigos fontes, componentes re-utilizáveis de BI e interfaces plenamente customizáveis. A plataforma executa processos editáveis que podem ser integrados com processos de negócios. Isto resulta em soluções altamente customizadas.
Orientação a Ferramentas - A plataforma de BI é centrada em processos e soluções. Ela não é projetada para ser um conjunto de ferramentas isoladas, mas para ser um sistema completamente integrado.
Extensão - O código fonte é fornecido. A infra-estrutura, componentes, mecanismos e interfaces podem ser facilmente modificados. O dinheiro salvo em gastos com licenças pode ser direcionado para extender a plataforma em uma área específica. A estrutura do produto é pública.
Foco em Relatórios e Análise - A plataforma de BI é centrada em processos, baseada em workflow e direcionada a regras de negócios. Ela pode ser facilmente integrada aos processos de negócios e tem facilidades para a geração de relatórios. Regras de negócios são usadas para identificar problemas e exceções; e processos auditados são executados para resolvê-las.
Influência em processos - A plataforma de BI acompanha a entrega de informações e permite processos de negócios customizados serem iniciados pelos receptores da informação. A entrega de um relatório não é o final da linha. Relatórios de performance de processos e modelos podem ser gerados. Ações tomadas podem ser avaliadas, comparando-as com metas, para mensurar a efetividade do processo. A plataforma oferece facilidades automáticas para realizar esta tarefa.
Auditoria - A plataform de BI inclui robustos processos de rastreamento e auditoria. A história de uma situação pode ser acessada, incluindo as ações tomadas, discussões/comentários e informações de suporte.
Prototipagem - O licenciamento da plataforma permite que a prototipagem seja
PentahoTM Artigo Técnico 15 realizada sem grandes investimentos.
Flexibilidade da Licença - O licenciamento da plataforma de BI é flexível e oferece valor ao cliente, pois o BI é somente parte de um processo de negócios, adicionando valor incremental. Além disto, o licenciamento por CPU a custos razoáveis abre a possibilidade aplicações extranet que não são realistas com ferramentas tradicionais, baseadas em licenciamento por
usuário.

* O Pentaho é desenvolvido na linguagem Java (JEE /Hibernate / portlets)

Downloads:
http://community.pentaho.com/sourceforge/

Wiki:
http://wiki.pentaho.com

Grupo de usuários Pentaho:
http://br.groups.yahoo.com/group/pentahobr/

09 dezembro 2008

Dicas rápidas

Splash Screen

Em linha de comando:

java -splash:images/nome_da_sua_imagem.extensao SplashDemo


No manifest.mf


Manifest-Version: 1.0
Main-Class: NomedaClasse
SplashScreen-Image: NomedaImagem.extensao


Aplicação no System Tray


import java.awt.*;

public class Teste
{
public static void main(String [] args) throws Exception{
SystemTray tray = SystemTray.getSystemTray();
Image image = Toolkit.getDefaultToolkit().getImage("image.gif");
tray.add(new TrayIcon(image));
}
}


Impressão


import java.io.File;

public class Teste
{
public static void main(String [] args) throws Exception{
java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
desktop.print(new File("c:/seuarquivo.txt"));
}
}


Abrir browser default


import java.io.File;

public class Teste
{
public static void main(String [] args) throws Exception{
java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
desktop.browse(new URI("http://www.site.com"));
}
}



Edição de arquivos


import java.io.File;

public class Teste
{
public static void main(String [] args) throws Exception{
java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
desktop.edit(new File("c:/seuarquivo.txt"));
}
}


Cliente de e-mail padrão


import java.io.File;

public class Teste
{
public static void main(String [] args) throws Exception{
java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
desktop.mail();
//ou
desktop.mail(new URI("mailto:nome@isp.com"));
}
}


Abrir arquivo


import java.io.File;

public class Teste
{
public static void main(String [] args) throws Exception{
java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
desktop.open(new File("c:/seuarquivo.txt"));
}
}

17 novembro 2008

ROME: Para Ler RSS Fácil.


O Rome é um conjunto de ferramentas para ler, gerar e publicar feeds Atom e RSS. O núcleo de sua API, depende somente do JDOM e suporta formatos como RSS 0.90, RSS 0.91 Netscape, RSS 0.91 Userland, RSS 0.92, RSS 0.93, RSS 0.94, RSS 1.0, RSS 2.0, Atom 0.3, and Atom 1.0.

Neste post irei demonstrar o código para leitura de RSS/Atom, que com o ROME é muito simples. A classe abaixo contém um exemplo básico disto imprimindo data de publicação, título e descrição:

import java.net.URL;
import java.text.SimpleDateFormat;
import com.sun.syndication.feed.synd.SyndEntryImpl;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

public class LeitorRSS {

private URL feedSource; //URL do feed
private SyndFeedInput input ; //leitor do XML recebido na url.
private SyndFeed feed ; //contém métodos para manipulação dos elementos RSS
private SimpleDateFormat formater = new SimpleDateFormat("dd/MM/yyyy");

//Neste método todo o Feed é lido, para manipulação em memória.
public LeitorRSS (String url) {
try {
feedSource = new URL(url);
input = new SyndFeedInput();
feed = input.build(new XmlReader(feedSource));
} catch (Exception e) {
e.printStackTrace();
}
}

//neste método os elementos contidos do Feed são impressos, o ROME já possui getters e setters para seus elementos.
public void imprimir() {
SyndEntryImpl item =null;
for (Object entry : feed.getEntries()){
item = (SyndEntryImpl)entry;
System.out.println( formater.format( item.getPublishedDate() ));
System.out.println(item.getTitle());
System.out.println(item.getDescription().getValue().replaceAll("<[^<>]+>", "").trim()); //retira tags HTML do campo descrição.
}
}

public static void main(String [] args){
LeitorRSS leitor = new LeitorRSS("http://www.theserverside.com/rss/theserverside-rss2.xml");
leitor.imprimir();
}
}
O ROME torna muito fácil a manipulação desses tipos de conteúdo, proporcionando multiplos usos de suas funcionalidades.

Abraços.

Fonte:

https://rome.dev.java.net/

09 novembro 2008

Gerando o calendário de 2009

Como o tempo passa! Já estamos no mês de novembro e logo vem as festas de fim de ano. E sempre temos uma necessidade: calendário. Quem não tem aquela "folhinha" , pendurada em algum lugar da casa, ou na mesa do escritório ?

Acredito que , a depender de como é feito, o trabalho de desenhar um calendário é um pouco complicado. Pra facilitar a vida de quem ainda não tem um calendário de 2009, ou quer fazer um, a classe GregorianCalendar ajuda bastante. A classe abaixo contém um método que gera o calendário para o mês especificado:


import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Calendario {

static NumberFormat formatter = new DecimalFormat("00");

public static void main (String [] args){
for(int i=0; i<=11;i++)
printCalendar(2009, i, 1);
}

public static void printCalendar(int year, int mounth, int day){
Calendar cal = new GregorianCalendar(year,mounth, day);
boolean inicio = false;
System.out.println("D S T Q Q S S");

for (int i = 1 ; i<=6; i++){//semanas
for (int w = 1 ; w<=7; w++){//dias
if (w==cal.get(Calendar.DAY_OF_WEEK)){inicio = true;}//início da escrita
if(inicio){
if((day-1)==cal.getActualMaximum(Calendar.DAY_OF_MONTH)){
break;
}//parada no final do mês

System.out.print(formatter.format(day++)+" ");
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
}


Executando o main, teremos o calendário de 2009 pronto. A formatação e reuso uso em taglibs ficam a gosto.

Abraços.

03 novembro 2008

Tocando arquivos MIDI com o padrão Proxy


Há um tempo atrás (especificamente 2004), publiquei um tutorial no site da comunidade do JavaFree.org, cujo título era Desenvolvendo um sequenciador MIDI com java. Agora, estudando um pouco mais o padrão de projeto Proxy, e fazendo alguns testes, vi que a api java.sound possui um recurso para desabilitar/habilitar trilhas em uma música.

Vamos ver como isso funciona?

O padrão funciona de forma a definir um objeto transparente que procure outro objeto, através de uma implementação interna. Com isso temos benefícios como desacloplamento, controle de acesso e cache, por exemplo.

Utilizaremos este padrão para executar uma música MIDI, e disponibilizar a opção de tocar as faixas da mesma separadamente. Primeiramente temos a classe que é o RealSubject da nossa pequena aplicação, ela é responsável para interação com o dispositivo MIDI do sistema operacional. Ela contém todas as funções para a execução, parada ou desabilitação das suas trilhas.

RealMidi.java

import java.io.File;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;

public class RealMidi implements IMidi {

private Sequencer sequencer;
private Sequence sequence;

public RealMidi(String arquivo) {
try {
sequencer = MidiSystem.getSequencer();
sequence = MidiSystem.getSequence(new File(arquivo));
sequencer.open();
sequencer.setSequence(sequence);
} catch (Exception e) {
e.printStackTrace();
}
}

public int getTracks(){
return sequence.getTracks().length;
}

@Override
public void enable(int numero) {
sequencer.setTrackMute(numero, !sequencer.getTrackMute(numero));
if (sequencer.getTrackMute(numero)) {
System.out.println(numero + " [OFF]");
} else {
System.out.println(numero + " [ON]");
}
}

@Override
public void start() {
sequencer.start();
}

@Override
public boolean isRunning() {
return sequencer.isRunning();
}

@Override
public void stop() {
sequencer.stop();
sequencer.close();
}

}

Percebemos que esta classe implementa uma interface, que também é implementada pela classe que será o nosso proxy.

IMidi.java

public interface IMidi {

void enable(int numero);

void start();

boolean isRunning();

void stop();

}

Temos a classe que será o proxy e que irá, além de repassar chamadas para a classe
RealMidi, fazer um cache do arquivo MIDI. Isso evitará que o mesmo seja acessado diversas vezes desnecessariamente. isto pode ser verificado nas operações start, stop e isRunnig.

ProxyMidi.java

public class ProxyMidi implements IMidi{

private RealMidi realMidi;
private String arquivo;

public ProxyMidi(String arquivo) {
this.arquivo = arquivo;
}

@Override
public void enable(int numero) {
if (numero < realmidi ="=" realmidi =" new">

Agora temos um sequenciador implementado com uma função a mais, que é a de escolher as trilhas que devem ser desabilitadas. Agora é só fazer uma classe que seja o cliente do padrão.

JPlayer.java

import java.util.Scanner;

public class JPlayer {

public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
IMidi midi = new ProxyMidi("sua_musica.mid");
midi.start();

System.out.println("Informe o número da trilha para habilitar/desabilitar a saída de som:");
int numero;
while (midi.isRunning()) {
numero = teclado.nextInt();
midi.enable(numero);
}
midi.stop();
}
}

Bom, como o resultado disso não dá pra colocar aqui (só ouvindo mesmo), então fica o convite para que você mesmo teste, ok ?

Indicações:

[1] http://dofactory.com/Patterns/PatternProxy.aspx
[2] http://www.javafree.org/javabb/topic-3102-Desenvolvendo+um+sequenciador+MID+com+java
[3] http://www.midinet.com.br/ (Para quem não tem arquivos MIDI)

02 novembro 2008

Boas Vindas

Para dar as boas vindas a todos que irão visitar este blog, gostaria de dizer que este espaço é para explicitar algumas idéias e resultados de pesquisas individuais em tecnologia. Nada mais coerente com a expressão in vitro, muito usada em outras àreas do conhecimento, denotando um sentido de experimentação. Com isso, seja lá qual for o post, espero seguir esta linha e trazer sempre bons experimentos (sejam inéditos ou não).

Um abraço à todos,

Cleuber