• Tweet

• Tweet

Certo dia me foi passado uma tarefa(em C#) na qual deveria executar um bloco composto por várias linhas. Cada linha desse bloco que fosse processada deveria incrementar uma barra de progresso e mostrar qual linha foi processada. Pensei: “iiiih vou ter que trabalhar com Thread“.

Dei uma olhada rápida na api do C#. Até que o@fredpolicarpo disse: “Usa o a classe BackgroundWorker“. Foi então que vi a facilidade de trabalhar de forma assíncrona em C#.

Você pode ver o tutorial que ele fez sobre BackgroundWorker em C# nesse link.

Pensei: “Vou procurar algo para java”, porque também precisei fazer algo em java que usasse thread. Então achei um link de um tutorial de um cara chamado  Richard Bair (link do tutorial).

Fiz um exemplo usando as classes que ele fez. Não vou detalhar as classes que ele criou, mas no final do post você vai encontrar o projeto completo para eclipse.

import org.jdesktop.swingx.event.BackgroundEvent;

public class Aplicacao {

	private org.jdesktop.swingx.BackgroundWorker worker;

	public static void main(String[] args) {
		/**
		 * O Background Worker só funciona se for executado por EDT(Event Dispatch Thread)
		 */
		java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
            	new Aplicacao().inicie();
            }
        });
	}

	public Aplicacao(){
		inicieBackground();
	}

	private void inicieBackground(){
		worker = new org.jdesktop.swingx.BackgroundWorker();
		/**
		 * Aqui faz as configurações de quais métodos o BackgroundWorker vai chamar
		 * de acordo com os eventos
		 */
		worker.addBackgroundListener(new org.jdesktop.swingx.event.BackgroundListener() {
            public void process(org.jdesktop.swingx.event.BackgroundEvent evt) {
            	/**
            	 * Método chamado quando deseja-se informar alguma coisa durante o processamento.
            	 * Por exemplo, incrementar uma barra de progresso durante o processamento
            	 */
                informeResultado(evt);
            }
            public void started(org.jdesktop.swingx.event.BackgroundEvent evt) {
            	/**
            	 * Método chamado quando antes de iniciar o processamento
            	 */
                iniciaProcessamento(evt);
            }
            public void done(org.jdesktop.swingx.event.BackgroundEvent evt) {
            	/**
            	 * Método chamado depois que o processamento foi concluído
            	 */
                concluiProcessamento(evt);
            }
            public void doInBackground(org.jdesktop.swingx.event.BackgroundEvent evt) {
            	/**
            	 * Método chamado para fazer o processamento em Background
            	 */
                executaProcessamentoEmBackground(evt);
            }
        });
	}

	private void inicie() {
		/**
		 * Inicia o background
		 */
		worker.execute();
	}

	private void iniciaProcessamento(BackgroundEvent evt) {
		System.out.println("Iniciando Processamento.");
	}

	private void executaProcessamentoEmBackground(BackgroundEvent evt) {
		System.out.println("Executando Processamento.");

		for(int i=1; i <= 10; i++){
			if((i*100) % 10 == 0){
				// Informa a porcetagem
				evt.getWorker().setProgressPercent((i*100) / 10);
				// O publish envia os dados a serem informados(no nosso caso a linha processada).
				evt.getWorker().publish("Linha processada: " + i);

				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
				}
			}
		}
	}

	private void informeResultado(BackgroundEvent evt) {
		// Aqui obtem os dados a serem exibidos(a linha processada)
		Object[] valor = evt.getData();
		String linhaProcessada = (String) valor[0];

		System.out.println(linhaProcessada);
		//Obtem o valor atual da porcentagem
		System.out.println(evt.getWorker().getProgressPercent() + "% Processado.");
	}

	private void concluiProcessamento(BackgroundEvent evt) {
		System.out.println("Processamento Concluido.");
	}
}

Não é tão completo como do C# mas facilita muito o trabalho assíncrono.

No mais é isso ae. Até!

Clique arqui para fazer download do exemplo.