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 Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos 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 Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos 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 Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos Framework Quartz

Agendamento com Java SE 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);

}

}

Agendamento com Java SE

• DEMO

Agenda

Conceitos Gerais Estudo de Caso Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos Framework Quartz

Agendamento com Java EE 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.

Agendamento com Java EE

Agendamento com Java EE 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

}

Agendamento com Java EE 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

}

}

Agendamento com Java EE 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)

javax.ejb.TimerService 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)

javax.ejb.TimerService 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.1public 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.

Agendamento com Java EE

• DEMO

Agenda

Conceitos Gerais Estudo de Caso Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos Framework Quartz

Agendamento com Java SE 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

Agendamento com Java EE 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 Agendamento com Java SE Agendamento com Java EE Comparativo entre os modelos 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 Quartzpublic 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

• DEMO