agendamento de tarefas com java se e ee

Iniciativa Globalcode Agendamento de Tarefas com Java SE e EE Open-source Education

Palestrante

Vinicius M. Senger

Trabalha com desenvolvimento de softwares a mais de 12 anos;

Foi instrutor e consultor Java da: Sun do Brasil, Oracle e Microsoft;

Palestrante em diversos eventos nacionais e no JavaOne (maior evento Java dos Estados Unidos);

Certificações: Java Programmer 1.4, Sun Certified Enterprise Architect P1, Sun Official Instructor, Oracle Instructor, Microsoft Certified Professional, Microsoft Certified Trainner;

Diretor Técnico e fundador da Globalcode;

Palestrante

Kleber Xavier

Formado em Engenharia Mecatrônica pela POLI-USP e Mestrando em Engenharia de Software pelo IME-USP

Experiência Internacional em projetos em Cingapura e Equador

Certificações :Java Programmer(SJCP), Web Component Developer(SCWCD), Business Component Developer(SCBCD) e Enterprise Architect(SCEA-I).

Instrutor Globalcode;

Agenda

Conceitos Gerais

Estudo de Caso

Agendamento com Java SE

Agendamento com Java EE

Comparativo entre os modelos

Framework Quartz

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Conceitos Gerais

O agendamento permite a programação de tarefas para serem executadas em um determinado horário.

Tipos de agendamento:

Periódico: a tarefa é executada diversas vezes de acordo com um intervalo pré-determinado.

Execução única (one-shot): a tarefa é executada uma única vez no horário programado.

Conceitos Gerais

Exemplos de utilização de agendamento:

Realizar backups periódicos;

Gerar relatórios diários de vendas;

Enviar e-mails de expiração de senha para usuários;

Monitorar a criação de novos arquivos em determinados diretórios.

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Estudo de Caso

Para ilustrar o agendamento de tarefas em Java iremos trabalhar com um sistema de verificação de expiração de reservas.

As reservas podem corresponder a qualquer tipo de reserva (restaurante, hotel, passagens aéreas, etc.)

O usuário pode cadastrar ou cancelar agendamentos para verificação de expiração de reservas através de uma tela Swing.

Estudo de Caso

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Desde a versão 1.3 estão disponíveis duas classes para agendamento de tarefas em Java:

java.util.TimerTask: representa a tarefa a ser agendada.

java.util.Timer: representa o coordenador ou agendador de tarefas.

java.util.TimerTask

Classe abstrata que implementa a interface java.lang.Runnable.

Para utilizá-la cria-se uma sub-classe que implemente o método run( ).

Ex:

public class TarefaAgendada extends TimerTask {

public void run() {

// Tarefa a ser agendada

}

}

java.util.TimerTask

Podemos cancelar a tarefa agendada através do método cancel().

Permite também a obtenção da data de sua última execução através do método long scheduledExecutionTime().

java.util.Timer

Classe que representa a Thread que irá executar a tarefa agendada (TimerTask).

Possui métodos para agendamentos periódicos e de execução única (one-shot).

Podemos especificar o horário de agendamento através de um objeto java.util.Date ou um tempo em milissegundos.

java.util.Timer

Para o agendamento periódico temos duas situações:

Atraso fixo (fixed-delay): o período é considerado a partir da última execução da tarefa.

Taxa fixa (fixed-rate): o período é considerado a partir da primeira execução da tarefa.

java.util.Timer

Métodos para agendamento de execução única:

schedule (TimerTask tarefa, Date inicio)

schedule (TimerTask tarefa, long atrasoAteInicio)

Métodos para agendamento de execução periódica:

schedule (TimerTask tarefa, Date inicio, long periodo)

schedule (TimerTask tarefa, long atrasoAteInicio, long periodo)

scheduleAtFixedRate (TimerTask tarefa, Date inicio, long periodo)

scheduleAtFixedRate (TimerTask tarefa, long atrasoAteInicio, long periodo)

Agendamento com Java SE Ex: import java.util.Timer; public class Main { public static void main(String[] args) { TarefaAgendada tarefa = new TarefaAgendada(); Timer agendador = new Timer(); agendador.schedule(tarefa,5000,5000); } }

DEMO

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Desde a versão 1.4 foi criado o serviço de timer para os componentes EJB.

Gerenciado pelo container EJB.

Baseado em três elementos:

javax.ejb.Timer: representa o agendamento de uma tarefa.

javax.ejb.TimerService: representa o coordenador ou agendador de tarefas.

EJB: componente que deve implementar a tarefa agendada.

Criando uma tarefa agendada com EJB 2.1:

Implementamos a interface javax.ejb.TimedObject e implementamos o método ejbTimeout(Timer timer).

Ex:

public class TarefaAgendadaBean implements SessionBean, TimedObject {

public void ejbTimeout(Timer timer) {

//tarefa agendada

}

//outros métodos de EJB

}

Criando uma tarefa agendada com EJB 3.0:

Usar a anotação @timeout no método desejado.

Ex:

@Stateless

public class TarefaAgendadaBean {

@timeout

public void tarefa(Timer timer) {

//tarefa agendada

}

}

Com EJB 3.0, o método agendado pode ter qualquer nome, mas deve receber como parâmetro um objeto Timer.

Também podemos utilizar a mesma estratégia de EJB 2.1 (implementar a interface TimedObject), ou configurar o método agendado no deployment descriptor com a tag <timeout-method>.

Cada EJB pode ter apenas um método agendado.

javax.ejb.TimerService

Para criar o agendamento, o EJB deve se registrar no serviço de timer.

Isto é feito chamando-se um dos métodos de agendamento de TimerService.

Os agendamentos suportados são:

Agendamento de tarefa para execução única (one-shot)

Agendamento de tarefa periódica com taxa fixa (fixed-rate)

Utilizamos um dos seguintes métodos para criar um agendamento:

createTimer (Date inicio, Serializable info)

createTimer (long atrasoAteInicio, Serializable info)

createTimer (Date inicio, long periodo, Serializable info)

createTimer (long atrasoAteInicio, long periodo, Serializable info)

O acesso ao serviço de Timer é feito através do EJBContext do componente.

O agendamento em si é feito de maneira programática, não declarativa.

Também podemos listar todos os agendamentos criados através do método getTimers().

Agendamento com Java EE Exemplo para EJB 2.1 public class TarefaAgendadaBean implements SessionBean, TimedObject { SessionContext ctx; public void setSessionContext(Context ctx) { this.ctx = ctx; } public void agendarTarefa() { TimerService agendador = ctx.getTimerService(); agendador.createTimer(5000,5000,null); } //demais métodos }

Agendamento com Java EE Exemplo para EJB 3.0 @Stateless public class TarefaAgendadaBean { @Resource SessionContext ctx; public void agendarTarefa() { TimerService agendador = ctx.getTimerService(); agendador.createTimer(5000,5000,null); } //demais métodos }

javax.ejb.Timer

Os métodos chamados para executar a tarefa agendada recebem como parâmetro um objeto Timer, que representa o agendamento.

Um mesmo componente pode receber mais de um agendamento.

Através do objeto Timer é possível chamar os seguintes métodos:

cancel() : cancela o agendamento.

getInfo() :retorna o parâmetro do tipo Serializable passado para o TimerService na criação do Timer.

DEMO

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Vantagens:

Simplicidade

Não é necessário nada além do Java SE

Desvantagens:

Perda do agendamento com queda da JVM

Somente dois tipos de agendamento

Não permite configuração declarativa

Vantagens:

Reaproveitamento de componentes existentes

Utilização de serviços do container

Recuperação automática do agendamento em caso de queda do servidor

Desvantagens:

Exige um container EJB

Somente dois tipos de agendamento

Não permite configuração declarativa

Agenda

Conceitos Gerais

Estudo de Caso

Framework Quartz

Framework Quartz

Framework para agendamento de tarefas criado por James House.

Disponível em http://www.opensymphony.com/ quartz

Apresenta recursos não disponíveis no agendamento tradicional com Java SE e Java EE:

Configuração declarativa

Agendamentos com regras de horário mais complexas

Framework Quartz

Com o Quartz a tarefa a ser executada é representada por uma classe que implementa a interface org.quartz.Job e implementa o método execute(JobExecutionContext ctx).

Ex:

public class TarefaAgendada implements Job {

public void execute(JobExecutionContext ctx) throws JobExecutionException {

//tarefa a ser executada

}

}

Framework Quartz

O agendador é representado por um objeto da classe org.quartz.Scheduler e é obtido através de uma classe Factory.

Ex:

Scheduler agendador = StdSchedulerFactory.getDefaultScheduler();

Após a criação de um agendamento que pode ser feita via programação ou arquivo de configuração (declarativa), iniciamos o processamento através do método start().

Ex: agendador.start();

Framework Quartz

Criação de agendamento via programação:

Construímos um objeto JobDetail que contém os detalhes do agendamento, utilizando o construtor JobDetail ( String nome, String grupo, Class tarefa)

Construímos um objeto Trigger que representa a periodicidade do agendamento.

Cadastramos o agendamento no objeto Scheduler através do método scheduleJob(JobDetail detalhes, Trigger acionador)

Framework Quartz public class Main { public static void main(String[] args) { Scheduler agendador = StdSchedulerFactory.getDefaultScheduler(); JobDetail detalhe = new JobDetail(“job1”,”grupo1” ,TarefaAgendada.class); Trigger acionador = TriggerUtils.makeHourlyTrigger(1); acionador.setName(“Trigger1”); acionador.setStartTime(new Date()); agendador.scheduleJob(detalhe,acionador); agendador.start(); } }

Framework Quartz

Criação de agendamento declarativo:

Configuramos o carregamento automático de tarefas no arquivo quartz.properties.

org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.JobInitializationPlugin

Criamos um arquivo quartz_jobs.xml com a configuração dos agendamentos desejados.

Framework Quartz Exemplo de quartz_jobs.xml: <quartz> <job> <job-detail> <name>job1</name> <group>grupo1</group> <job-class> br.com.globalcode.TarefaAgendada </job-class> </job-detail>

Framework Quartz <trigger> <simple> <name>testeTrigger</name> <group>DEFAULT</group> <start-time>2006-12-01 16:09:00 PM</start-time> <repeat-count>5</repeat-count> <repeat-interval>10000</repeat-interval> </simple> </trigger> </job> </quartz>

Framework Quartz Exemplo de classe que utiliza o agendamento declarativo: public class Main { public static void main(String[] args) { Scheduler agendador = StdSchedulerFactory.getDefaultScheduler(); agendador.start(); } }

Framework Quartz