Exemplo de utilização do Quartz

O que é o Quartz?


É um framework de agendamento de tarefas.


Com ele você pode por exemplo agendar uma tarefa para executar: uma vez por dia, um vez por semana, uma vez por mês, uma vez a cada 5 minutos etc.


Obs: A finalidade desse post é mostrar de forma rápida e simples algumas funcionalidade desse framework, para que você inicie seu aprendizado no mesmo. Para maiores informações entre no site do Quartz, pois o mesmo tem muito mais recursos do que o apresentado aqui!


Utilizando o Quartz:


Faça o download da versão mais recente no site: http://www.quartz-scheduler.org/, descompacte o arquivo e copie o jar (quando esse post foi escrito a versão era quartz-1.8.3.jar) para o diretório lib de seu projeto.


Criaremos as seguintes classes:
1) Agenda - Responsável pelo agendamento das tarefas.
2) JobDia - Job que será executado uma vez por dia.
3) JobHora - Job que será executado a cada 60 minutos.


Classe Agenda:


 public class Agenda implements ServletContextListener {
 public static Scheduler sched;
 private Logger log;

 @SuppressWarnings("static-access")
 protected void init() throws ObjectAlreadyExistsException {

  try {
   /* Fábrica para criar instância de Scheduler */
   StdSchedulerFactory schedFactory = new StdSchedulerFactory();

   getLog().info("---------------- Criar Agendador ----------------");
   Agenda.sched = schedFactory.getScheduler();


   /* ************************Inicio Job Hora *****************************/
   getLog().info("---------------- Criando Tarefa: JobHora para ser executada a cada 60 minutos ----------------");
   JobDetail jobHora = new JobDetail("JobIntegraBysoft",Scheduler.DEFAULT_GROUP, JobHora.class);

   getLog().info("---------------- Criar Gatilho Job Hora  ----------------");
   SimpleTrigger sptJobHora = new SimpleTrigger(
     "JobHora", sched.DEFAULT_GROUP, new Date(), null,
     SimpleTrigger.REPEAT_INDEFINITELY, 3600L * 1000L);

   getLog().info("---------------- Faz o Agendamento de JobHora ----------------");
   java.util.Date ft = sched.scheduleJob(jobHora, sptJobHora);

   /* Imprime informações do Job */
   getLog().info(jobHora.getFullName() + " Foi programado para funcionar em: "
     + ft + " e repete baseado na expressão: ");
   /* ************************ Fim Job Hora *******************************/


   /* ************************ Inicio Job Dia *****************************/
   getLog().info("---------------- Criando tarefa: JobDia para ser executado todos os dias as 22 horas ----------------");
   JobDetail JobDia = new JobDetail("JobDia",Scheduler.DEFAULT_GROUP,
      JobDia.class);

   getLog().info("---------------- Criar Gatilho Para JobDia  ----------------");
   CronTrigger ctgJobDia = new CronTrigger("JobDia", sched.DEFAULT_GROUP);
   /* setCronExpression(* Segundos,* Minutos,* Horas,* Dias do mês,* Mês,* Dias da semana) */
   ctgJobDia.setCronExpression("0 00 22 * * ?");

   getLog().info("---------------- Faz Agendamento de JobDia ----------------");
   java.util.Date dataAniversariosDoDia = sched.scheduleJob(JobDia, ctgJobDia);

   /* Imprime informações do Job */
   getLog().info(JobDia.getFullName() + " Foi programado para funcionar em: "
     + dataAniversariosDoDia + " e repete baseado na expressão: "); 
   /* ************************ Fim Job Dia **************************** */


   /* Iniciar execução do Scheduler */
   Agenda.sched.start();   


  } catch (Exception e) {
   System.out.println("\n\nErro ao tentar iniciar Scheduler .\n\n");
   e.printStackTrace();
  }
 }


 public void contextInitialized(ServletContextEvent ce) {
  try{
   init();
  }catch (Exception ex) {
   ex.getStackTrace();
  }
 }


 public void contextDestroyed(ServletContextEvent arg0) {
  // Finaliza o schedule
  restart();
 }


 public void restart() {
  try {
   Agenda.sched.shutdown(true);
  } catch (Exception ex) {
   getLog().error("Erro ao tentar reiniciar as tarefas");
   getLog().error(ex.getMessage(), ex);
  }
 }


 protected Logger getLog() {
  if (this.log == null) {
   this.log = Logger.getLogger("AÇÃO : ");
  }
  return this.log;
 }


}


 
Adicione o listener no seu web.xml
<listener>
  <listener-class>br.com.lpc.ganymede.quartz.Agenda</listener-class>
</listener>





Classe JobHora


public class JobHora implements Job {
 @Override
 public void execute(JobExecutionContext arg0) throws JobExecutionException {
  System.out.println("Executando Job Hora");
 }
}







Classe JobDia


public class JobDia implements Job {
 @Override
 public void execute(JobExecutionContext arg0) throws JobExecutionException {
  System.out.println("Executando Job Dia");
 }
}


Execute a aplicação, e veja o resultado na console:

23:06:42,330 INFO  [StdSchedulerFactory] Quartz scheduler version: 1.4.5
23:06:42,330 INFO  [AÇÃO : ] ---------------- Criando Tarefa: JobHora para ser executada a cada 60 minutos ----------------
23:06:42,334 INFO  [AÇÃO : ] ---------------- Criar Gatilho Job Hora  ----------------
23:06:42,338 INFO  [AÇÃO : ] ---------------- Faz o Agendamento de JobHora ----------------
23:06:42,339 INFO  [AÇÃO : ] DEFAULT.JobIntegraBysoft Foi programado para funcionar em: Wed Oct 20 23:06:42 BRST 2010 e repete baseado na expressão:
23:06:42,339 INFO  [AÇÃO : ] ---------------- Criando tarefa: JobDia para ser executado todos os dias as 22 horas ----------------
23:06:42,341 INFO  [AÇÃO : ] ---------------- Criar Gatilho Para JobDia  ----------------
23:06:42,348 INFO  [AÇÃO : ] ---------------- Faz Agendamento de JobDia ----------------
23:06:42,351 INFO  [AÇÃO : ] DEFAULT.JobDia Foi programado para funcionar em: Wed Oct 20 23:07:00 BRST 2010 e repete baseado na expressão:
23:06:42,351 INFO  [QuartzScheduler] Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
23:06:42,480 INFO  [STDOUT] Executando Job Hora
23:06:47,421 INFO  [ServerImpl] JBoss (Microcontainer) [5.0.0.GA (build: SVNTag=JBoss_5_0_0_GA date=200812042120)] Started in 52s:48ms
23:07:00,012 INFO  [STDOUT] Executando Job Dia


Bons estudos!

Exemplos de utilização do Criteria

public class ExemplosCriteria<T> {
 protected Class<T> persistentClass;
 protected Session session;

 public ExemplosCriteria(Session session, Class<T> persistentClass){
  this.session = session;
  this.persistentClass = persistentClass;
 }

 /** Retorna todos os registros da tabela com ordenação */
 @SuppressWarnings("unchecked")
 public List<T>findAll(String fieldOrder){
  Criteria c = this.session.createCriteria(persistentClass);
  c.addOrder(Order.asc(fieldOrder));
  return c.list();
 }

 /** Pesquisa de acordo com o campo e valor fornecido. retorna somente um objeto */
 @SuppressWarnings("unchecked")
 public T loadByField(String field, String value){
  Criteria c = this.session.createCriteria(persistentClass);
  c.add(Restrictions.eq(field, value));
  T t = (T) c.uniqueResult();
  return t;
 }

 /** Pesquisa de acordo com campo, valor (em qualquer posição do campo), ordena, e limita resultado */
 @SuppressWarnings("unchecked")
 public List<T> findByNameAnyWhere(String fieldName, String fieldValue,String fieldOrder, Integer maxResults){
   Criteria c = this.session.createCriteria(persistentClass);
   c.add(Restrictions.ilike(fieldName, fieldValue,MatchMode.ANYWHERE));
   c.addOrder(Order.asc(fieldOrder));
  
   if (maxResults != null) {  
    c.setMaxResults(maxResults);
   }
  
   return c.list();
 }

 /** Semelhante ao exemplo acima, porém, faz join em outras "tabelas/objetos" */
 @SuppressWarnings("unchecked")
 public List<T> findByNameAnyWhereJoin(String fieldName, String fieldValue,String fieldOrder, Integer maxResults){ 
   Criteria c = session.createCriteria(NotaFiscal.class, "nota");
   c.createAlias("nota.itens", "item",CriteriaSpecification.LEFT_JOIN);
   c.createAlias("item.usuario", "usuario",CriteriaSpecification.LEFT_JOIN);
   c.createAlias("usuario.unidadeOperacional", "unidade",CriteriaSpecification.LEFT_JOIN);
   c.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
   c.addOrder(Order.asc(fieldOrder));
  
   Integer numero = Integer.parseInt(fieldValue);
   c.add(Restrictions.eq(fieldName, numero));
   return c.list();  
 }

 /** OR/AND no criteria */
 @SuppressWarnings("unchecked")
 public List<Usuario> getChamadosAbertosUsuario(Usuario usuario){  
     Criteria c = session.createCriteria(Usuario.class);
   
     Criterion c1 = Restrictions.eq("status", "A");
     Criterion c2 = Restrictions.eq("status", "C");
     c.add(Restrictions.or(c1, c2));
   
     c.add(Restrictions.eq("usuario", usuario));
     c.addOrder(Order.desc("id"));
   
     return c.list();
 }

 /** Criteria com cache de query ativado */
 @SuppressWarnings("unchecked")
 public List<View_Vencimentos> getVencimetosDoCliente(Integer matrizId){
  Criteria c = session.createCriteria(View_Vencimentos.class);
  c.add(Restrictions.eq("id_matriz", matrizId));
  c.addOrder(Order.asc("vencimento"));
 
  c.setCacheable(true);
  c.setCacheMode(CacheMode.NORMAL);
  return c.list();
 }

}

Exemplo de teste unitário com o JUnit

Faça o download do jar no site do JUnit http://www.junit.org. Em seguida coloque-o no diretório lib de seu projeto.

Testando com o Junit:

O método getNomeCompleto da classe Usuario deve retornar o nome, seguido de um espaço e o ultimoNome.

Vamos testar com o JUnit para assegurar que temos um espaço em branco entre as duas propriedades:

Como podemos ver, o código funciona perfeitamente.

Agora veremos outra situação, onde ocorre uma falha:

 Uma pequena correção no método:

E o código passa no teste:

Esses são alguns exemplos de onde e como utilizar o JUnit.

Podemos fazer os testes sem a necessidade de uma interface gráfica. Isso acaba por reduzir o tempo, já que, com uma interface, seria necessário carregar o sistema, fazer os testes, corrigir erros, carregar novamente, testar novamente etc.

Hibernate: Tipos de consultas suportadas pelo Hibernate

Esse pequeno post é destinado aos novatos em Hibernate que geralmente tem dúvidas em relação aos tipos de pesquisa suportados por esse framework. Navegando nos fóruns encontramos vários nomes como (criteria, HQL, SQL Nativo etc.), essa salada de nomes pode complicar o inicio do aprendizado.

O que precisa ficar claro é que todas as opções abaixo são utilizadas para efetuar consultas no banco de dados. Cada uma com suas vantagens/desvantagens em relação às outras.

Esses são os tipos suportados pelo Hibernate:

1.       HQL

2.       JPA QL

3.       SQL Nativo

4.       Criteria

Exemplos simples:

HQL:

Ex1: from Usuario
Retorna todos os objetos da classe Usuario (não é necessário informar select antes do from).

Ex2: select from Usuario as u where u.nome = ‘Alexandre’
Exemplo utilizando apelido (u) e restrição (where).  A palavra chave (as) na definição do apelido é opcional.

JPA QL

Ex1: select from Usuario
Retorna todos os registros da classe Usuario (note que em JPA QL você deve informar select antes do from).

SQL Nativo

Ex1: List list = session.createSQLQuery(“select * from Usuario”)
                                               .addEntity(Usuario.class)
                                               .list();

Criteria

Ex1: List<Usuario> list = session.createCriteria(Usuario.class)
                                               .list();
Retorna todos os registros da classe Usuario.

Ex2: Usuario usuário = session.createCriteria(Usuario.class)
                                               .add(Restrictions.eq(“nome”,”Alexandre”)
                                               .uniqueResult();
Exemplo de consulta utilizando restrição e limitando o retorno a um único objeto.