agendamento de tarefas com java se e ee
Upcoming SlideShare
Loading in...5
×
 

agendamento de tarefas com java se e ee

on

  • 5,323 views

 

Statistics

Views

Total Views
5,323
Views on SlideShare
5,295
Embed Views
28

Actions

Likes
2
Downloads
74
Comments
0

1 Embed 28

http://www.slideshare.net 28

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

agendamento de tarefas com java se e ee agendamento de tarefas com java se e ee Presentation Transcript

  • 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
      • 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.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.
  • 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 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
    • DEMO