agendamento de tarefas com java se e ee
-
Upload
elliando-dias -
Category
Technology
-
view
4.287 -
download
2
Transcript of 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