Palestras SOA

SOA e Reúso na Prática
http://video.google.com/videoplay?docid=-5249880257239323129&hl=pt-BR#


SOA – Erros Comuns (Anti-Patterns) e Boas Práticas
http://video.google.com/videoplay?docid=8500982291404146742&hl=pt-BR#

Arvore B

Definição de uma arvore B:
http://www.youtube.com/watch?v=qXfPA6xqVlQ
Remoção em uma arvore B:
http://www.youtube.com/watch?v=XxFzd8s2u60
Inserção em uma arvore B:
http://www.youtube.com/watch?v=dBPJAM0Glls

Outro série que fala sobre arvore B
Árvores B - Parte 1
http://www.youtube.com/watch?v=3eJM4FGfUdU
Árvores B - Parte 2
http://www.youtube.com/watch?v=ANZBJw3a944

Balanced Scorecard por Kaplan

Kaplan fala um pouco sobre como o Balanced Scorecard é importante para empresas e para o governo.

Engenharia de software - video aula

Olá pessoal, hoje irei relacionar aqui um conjunto de links que dão uma boa revisão sobre a Engenharia de Software.

Claro que não substitui um aula presencial, mas para aqueles que precisam de uma forcinha antes das provas é bacana assisti-lo. Material, resumido, e bem direto, sem muita enrrolação.

Engenharia de Software I

Aula 01 - Part 01
http://www.youtube.com/watch?v=FmBWDwTqMbo
Aula 01 -Part 02
http://www.youtube.com/watch?v=-7jXQlAWaQQ

Aula 02 -Part 01 - Processo de software, cascata, evolutivo(prototipação e espiral) e baseado em componentes
http://www.youtube.com/watch?v=igeU6B5GmIU
Aula 02 -Part 02
http://www.youtube.com/watch?v=0fRv6o3aakw

Aula 03 -Part 01
http://www.youtube.com/watch?v=2Lh-JH3SfE4
Aula 03 -Part 02
http://www.youtube.com/watch?v=X5hJgvMeoEo

Aula 04 -Part 01
http://www.youtube.com/watch?v=G6yk7fLK3JY
Aula 04 -Part 02
http://www.youtube.com/watch?v=HT_SgcxSfjY

Aula 05 -Part 01
http://www.youtube.com/watch?v=qtbZjwLpvUg
Aula 05 -Part 02
http://www.youtube.com/watch?v=rGsx-WalKj8

Aula 06 -Part 01
http://www.youtube.com/watch?v=ya6eGnnFnrw
Aula 06 -Part 02
http://www.youtube.com/watch?v=uAZyCKs50kQ




Engenharia de Software II

Aula 01 - Part 01 - Fala sobre UML, diagrama de caso de uso,
http://www.youtube.com/watch?v=JkIk9-fgCQ8
Aula 01 -Part 02 - Fala sobre caso de uso, atores, associação e herança entre atores.
http://www.youtube.com/watch?v=jy5DDw0r2bM

Aula 03 - Part 01
http://www.youtube.com/watch?v=2r6VN54d4Lg
Aula 03 - Part 02
http://www.youtube.com/watch?v=2r6VN54d4Lg

Aula 04 - Part 01
http://www.youtube.com/watch?v=4Ul0jh9FICM
Aula 04 - Part 02
http://www.youtube.com/watch?v=z7LTP1A4pIg

Aula 05 - Part 01 - Diagrama de seqüência
http://www.youtube.com/watch?v=LTaDuh87nGk
Aula 05 - Part 02
http://www.youtube.com/watch?v=tB8Il8NMXFA

Aula 06 - Part 01
http://www.youtube.com/watch?v=7MSTQZL_-z0
Aula 06 - Part 02
http://www.youtube.com/watch?v=CjNo059eUpM

Aula 07 - Part 01
http://www.youtube.com/watch?v=f8FE85m3qaw
Aula 07 - Part 02
http://www.youtube.com/watch?v=hvysWO5oRyc

Diagrama de atividades - Parte 01
http://www.youtube.com/watch?v=w4C4cq4HV6U
Diagrama de Atividades - Parte - 02
http://www.youtube.com/watch?v=aBVFWXuYJCU

Projeto e diagrama de classes
http://www.youtube.com/watch?v=5wJQgMo_Qhs

Diagrama de classe e colaboração - Part 1
http://www.youtube.com/watch?v=tB8Il8NMXFA
Diagrama de classe e colaboração - Part 2
http://www.youtube.com/watch?v=LTaDuh87nGk

Programação Orientada à Objeto com AS3

Programação Orientada à Objeto com AS3: Introdução e Conceitos
http://vimeo.com/6911207

Programação Orientada à Objeto com AS3: Pacotes
http://vimeo.com/6984819

Padrões de Projeto

Padrões de Projeto
Motivação, Conceito, Diagramação baseada no jogo de gamão, desenvolvimento do código fonte...
Padrão de projeto lazy load
Parte 1
http://www.youtube.com/watch?v=_n6uruhx5u4
Parte 2
http://www.youtube.com/watch?v=RBSd81LB2os
Parte 3
http://www.youtube.com/watch?v=KcZrX80woN4


Padrões de Projeto: Plugin
Parte 1
http://www.youtube.com/watch?v=fUaDIfTjUYQ
Parte 2
http://www.youtube.com/watch?v=yS5Zmjrsk4A


Padrões de Projeto: Strategy
Parte 1
http://www.youtube.com/watch?v=NV9UmNICU14
Parte 2
http://www.youtube.com/watch?v=FTXn3DLtJII
Parte 3
http://www.youtube.com/watch?v=VGAm1dQb9X4


Padrões de Projeto: Visitor
Parte 1
http://www.youtube.com/watch?v=raSI1A2YwjA
Parte 2
http://www.youtube.com/watch?v=B2ZJXPl-Se0


Padrões de Projeto: Chain of Responsibility
Parte 1
http://www.youtube.com/watch?v=M_JUKwltHJ8
Parte 2
http://www.youtube.com/watch?v=om0WW9BmaZM
Parte 3
http://www.youtube.com/watch?v=a2VDKkmlbGY



Padrões de Projeto: Command
Parte 1
http://www.youtube.com/watch?v=fUEPswyc9YA
Parte 2
http://www.youtube.com/watch?v=WNJYcE2WmLU


Padrões de Projeto: Prototype
Parte 1
http://www.youtube.com/watch?v=FNpZSqclqmE
Parte 2
http://www.youtube.com/watch?v=l17skbbopS4


Padrões de Projeto: DAO
Parte 1
http://www.youtube.com/watch?v=JchwQ3-deDs
Parte 2
http://www.youtube.com/watch?v=Qj8BUMg5X0o
Parte 3
http://www.youtube.com/watch?v=Qj8BUMg5X0o

Padrões de Projeto - Abstract Factory
Parte 1
http://www.youtube.com/watch?v=L25hHRl3Fcs
Parte 2
http://www.youtube.com/watch?v=i4UN9BAnW70


Padrões de Projeto: Decorator
Parte 1
http://www.youtube.com/watch?v=vlaX8gDq3MQ
Parte 2
http://www.youtube.com/watch?v=hzeaUN7Bfjw
Parte 3
http://www.youtube.com/watch?v=cpasdWdDbYs


Padrões de Projeto: Proxy
Parte 1
http://www.youtube.com/watch?v=kz2eUXX5wC0
Parte 2
http://www.youtube.com/watch?v=OSBqSxveB-w
Parte 3
http://www.youtube.com/watch?v=anVssFJwh4M
Parte 4
http://www.youtube.com/watch?v=9cNNamAwR-U


Padroes de Projetos: State
Parte 1
http://www.youtube.com/watch?v=sTBnI-fqWw4
Parte 2
http://www.youtube.com/watch?v=ZNVBE_VEaRs


Padrões de Projeto: Memento
Parte 1
http://www.youtube.com/watch?v=pBrXznoDcuo
Parte 2
http://www.youtube.com/watch?v=1I4PVSch-l0
Parte 3
http://www.youtube.com/watch?v=qTtQ2jsj8TE


Padrao de Projeto: Bridge
Parte 1
http://www.youtube.com/watch?v=0xMcl1aTjrQ
Parte 2
http://www.youtube.com/watch?v=yP-r_Uudp-c


Padrões de Projeto: Mediator
Parte 1
http://www.youtube.com/watch?v=aLyE2visk-k
Parte 2
http://www.youtube.com/watch?v=pNPWoNmnyiM
Parte 3
http://www.youtube.com/watch?v=yEr-_iok3VU


Padrões de Projeto: Builder
Parte 1
http://www.youtube.com/watch?v=C0cK7QENSy4
Parte 2
http://www.youtube.com/watch?v=BNCUbXKMtPc


Padrões de Projeto: Strategy
Parte 1
http://www.youtube.com/watch?v=NV9UmNICU14
Parte 2
http://www.youtube.com/watch?v=FTXn3DLtJII
Parte 3
http://www.youtube.com/watch?v=VGAm1dQb9X4


Padrões de Projeto: Mediator
Parte 1
http://www.youtube.com/watch?v=aLyE2visk-k
Parte 2
http://www.youtube.com/watch?v=pNPWoNmnyiM
Parte 3
http://www.youtube.com/watch?v=yEr-_iok3VU

Videos na vimeo da bluesoft

Palestra de Business Intelligence
Nesta palestra Ismael Soares introduziu conceitos de Bunisiness Inteligence (BI) como DataWare House, Data Marts, Data Minnings, Cubos OLAP, ODS e muito mais.
http://vimeo.com/6962558

Introdução ao Groovy
http://vimeo.com/6850374

Scrum com Pronto!
http://vimeo.com/6735580

Entrevista com Wende Mendes sobre Programação em Par
http://vimeo.com/6935560

Entrevista com Luiz China sobre Testes na Bluesoft
http://vimeo.com/6814228

O que Aprendi no Just Java 2009 - Testes
http://vimeo.com/6753378

O que Aprendi no Just Java 2009 - Automação de projetos Java EE
http://vimeo.com/6754246

O que Aprendi no Just Java 2009 - UOL, Flex, AOP...
http://vimeo.com/6752701

Aulas de redes

Aula 01 - Fala um pouco sobre tipos e topologias de redes, além de alguns de seus componentes, como hub, switch, cabos, fibra ótica, roteador...
http://www.youtube.com/watch?v=V4MZuW1NKkA
http://www.youtube.com/watch?v=xgYdZDtj2Rs
http://www.youtube.com/watch?v=F03iSJFlFgA
http://www.youtube.com/watch?v=ck9S47MgDLA

Aula 02 - Começa a discorrer sobre protocolos de rede
http://www.youtube.com/watch?v=8w8rrcd48qE
http://www.youtube.com/watch?v=WRI7K2MbMHk
http://www.youtube.com/watch?v=3lpvJx2jdTo

Aula 03 - Fala sobre a camada fisica
http://www.youtube.com/watch?v=A_nFCyOh66s
http://www.youtube.com/watch?v=FxNNG43niaE
http://www.youtube.com/watch?v=Y3NZkuAkUgs

Aula 04 - Fala sobre a camada de enlace
http://www.youtube.com/watch?v=OT_Wik5Nb_M
http://www.youtube.com/watch?v=s7m9YgWT5mY
http://www.youtube.com/watch?v=RwCKCrG_8Us
http://www.youtube.com/watch?v=DhpihEf-fzo

Aula 05 - Camada de rede e transporte
http://www.youtube.com/watch?v=DBidehK5m7w
http://www.youtube.com/watch?v=IdVGgPzSLs8
http://www.youtube.com/watch?v=DudehBbQWWo
http://www.youtube.com/watch?v=4TSTQQSV0h0

Aula 06 - Camada de sessão, apresentação e aplicação
http://www.youtube.com/watch?v=N2EQx071IIg
http://www.youtube.com/watch?v=VMUDtKAwGrI
http://www.youtube.com/watch?v=vhPdXU6MMXA

Novo emprego - Dicas para o jovem profissional

Encontrei um video bacana que fala sobre como se portar em um novo emprego...

No geral ele fala que devemos manter um equilibrio em todos os sentidos, seja coportamento, seja dedicação, seja em situações como reuniões e conversas informais que acontecem no "café".

Gerenciamento de projetos - escopo

Ronnie Maschk fala de forma simples sobre gerenciamento de escopo do projeto
O video é intressante aborda: risco, escopo, wbs, entrega, dicionário da wbs :D
É basicamente um video sobre PMBOK

Video aula interessantes

Hoje vou indicar dois videos interessantes, são na verdade video aulas, ou se preferir webnars, veja a baixo os videos...



Disciplina de Sistemas Operacionais - Ciência da Computação - Professor Rafael Cancian



Como Instalar Linux com VMWare no Windows - Rafael Luiz Cancian

Chucky o agitador

Lendo o livro de James C. Hunter intitulado “Como se tornar um líder servidor”, encontrei logo no primeiro capítulo 1 algo do qual me identifiquei, na realidade identifiquei uma situação da qual vivenciei no passado, mas que não tinha argumentos suficientes para defender minhas convicções.

O autor do livro começa narrando sobre suas experiências profissionais, e na primeira estória conta sobre um personagem que encontra em várias de suas consultorias de nome fictício: Chucky. Chucky é um agitador, vive causando problemas a empresa e os diretores precisam “silenciá-lo” para que as atividades retornem ao normal.

James C. Hunter, conta que em suas experiência profissional, descobriu que nem sempre o “agitador” é o problema, que normalmente, ele é o único que tem coragem de dizer a verdade, e que esta verdade é que seus líderes falham. O difícil era ter coragem de dizer ao líder de que ele era o problema.

Bom, tudo isto que disse foi para introduzi-lo ao meu antigo problema. Que a meu ver cai bem neste cenário. Deixe-me explicar brevemente. Há algum tempo fui notificado de que um colega de trabalho seria demitido, nunca fui muito amigo, ou próximo deste profissional, mas já tinha uma imagem de que os motivos elencados para o seu desligamento não eram condizentes com o que eu vivenciava, e observava.

Diante desta situação resolvi a minha maneira tirar a prova sobre minhas impressões, descobri que estava certo, mais que isto, identifiquei claramente que em algumas situações ele falhou sim, mas que não era o único culpado, que na maioria esmagadora das vezes houve participação do líder envolvido naquele momento, seja por má instrução, seja por omissão.

Na época isto me deixou com o sentimento de que poderia fazer algo para tentar resolver a situação, afinal, a empresa investiu tempo e dinheiro, formando e capacitando tal profissional, esforço este que ao meu ver não deveriam e não poderiam ser simplesmente jogados fora, nós deveríamos encontrar uma forma de resolver esta situação sem que isto culminasse no infeliz “desligamento”.

Meus esforços foram em vão, pior que isto, para tentar resolver a situação e abrir os olhos dos diretores, arrisquei, e muito, até mesmo desobedeci a ordens diretas destes diretores, que por conseqüência me deixou com a imagem de um colaborador insubordinado (mais um Chucky na organização). Mas quer saber? Valeu o risco! Pois hoje, tenho a consciência tranqüila de fiz o certo, pois consegui verificar que minha opinião estava correta.

Demitir este profissional por causa de erros cometidos coletivamente, que incluíam a liderança do momento não é a atitude correta, oque está se fazendo nesta situação é criar um mártir, onde apenas um “paga” pelos erros de muitos, oque está se criando é um exemplo aos que ficam, exemplo este que acaba se voltando negativamente contra a organização.

Ouvi diversas vezes de vários funcionários que eles sentem que seus empregos estão ameaçados, que a empresa não lhe transmite segurança em suas funções. Ouvi até o exato relato: “Na empresa WXYS nós estamos sempre com a navalha no pescoço”. Relatos como este me comprovam que os lideres estão falhando, mais que isto suas falhas estão se tornando um problema contra eles mesmos.

Nesta experiência pude observar e aprender que quando um liderado erra, ele não erra sozinho, nunca. Sempre há a participação ou omissão do líder, e ser omisso é pior que participar do erro, pois não há se quer a possibilidade de aprender com o erro. Mas é possível estragar ainda mais a situação, o líder pode se esconder mais uma vez e eleger um mártir.

Hunter [1] afirma que: “O maior indicador de saúde ou doença organizacional está na liderança ou em sua ausência”. Neste caso em específico acredito que a saúde esta debilitada, os lideres são míopes diante de seus próprios problemas, e sofrem de deficiência auditiva, pois não ouvem seus liderados.


Ditado chinês: “O líder é o responsável pelo crescimento e declínio de qualquer coisa”

“Não há pelotões fracos – apenas líderes fracos” – Autor: General William Creech



[1] Hunter C. J (2006) - Como se tornar um líder servidor – Os princípios de liderança de o monge e o executivo

Calculando diferença entre datas

Hoje coloco aqui disponível a todos um exemplo de classe que utilizo para calcular diferença entre datas

package com.wealthsystems.sim.utils.date;

import java.util.Date;

/**
 * Calculate difference of dates
 * 
 * @author Clayton
 * 
 */
public class DateDiff {
    /**
     * Get difference in milliseconds
     * 
     * @param data1
     *            data mais antiga (natal)
     * @param data2
     *            data mais nova (ano novo)
     * @return
     */
    public static long inMiliseconds(Date data1, Date data2) {
 long diffMillis = data2.getTime() - data1.getTime();
 return diffMillis;
    }

    /**
     * Get difference in seconds
     * 
     * @param data1
     * @param data2
     * @return
     */
    public static long inSeconds(Date data1, Date data2) {
 long diffSecs = inMiliseconds(data1, data2) / (1000); // 604800
 return diffSecs;
    }

    /**
     * Get difference in minutes
     * 
     * @param data1
     * @param data2
     * @return
     */
    public static long inMinutes(Date data1, Date data2) {
 long diffMins = inMiliseconds(data1, data2) / (60 * 1000); // 10080
 return diffMins;
    }

    /**
     * Get difference in hours
     * 
     * @param data1
     * @param data2
     * @return
     */
    public static long inHours(Date data1, Date data2) {
 long diffHours = inMiliseconds(data1, data2) / (60 * 60 * 1000); // 168
 return diffHours;
    }

    /**
     * Get difference in days
     * 
     * @param data1
     * @param data2
     * @return
     */
    public static long inDays(Date data1, Date data2) {
 long diffDays = inMiliseconds(data1, data2) / (24 * 60 * 60 * 1000); // 7
 return diffDays;
    }

    public static String toStringInHour(Date data1, Date data2) {
 long hour = DateDiff.inHours(data1, data2);
 long minutes = DateDiff.inMinutes(data1, data2);
 long seconds = DateDiff.inSeconds(data1, data2);

 StringBuffer sb = new StringBuffer();
 sb.append(hour);
 sb.append(":");
 sb.append(minutes - (hour * 60));
 sb.append(":");
 sb.append(seconds - (minutes * 60));

 return sb.toString();
    }
}

Transferir bytes de um lado pro outro

Quando você quer transferir bytes de um lado pro outro via socket você pode utilizar várias estratégias, eu criei dois Iterators para facilitar esta tarefa.


Trecho da classe que envia

Socket s = new Socket("localhost", 8888);
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
byte[] nome = { 1, 2, 3, 4, 5, 6, 7 };

ByteArrayInputStream bytArrIn = new ByteArrayInputStream(nome);

SenderInputStreamIterator it = new SenderInputStreamIterator(in, out, bytArrIn);
while (it.hasNext()) {
   byte[] b = (byte[]) it.next();
   System.out.println(b[0]);
}

Trecho da classe que recebe

ServerSocket serv = new ServerSocket(8888);
Socket s = serv.accept();
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();

ByteArrayOutputStream byteArrOut = new ByteArrayOutputStream();
ReaderInputStreamIterator it = new ReaderInputStreamIterator(in, out);
while (it.hasNext()) {
  byte[] b = (byte[]) it.next();
  System.out.println(b[0]);

}

/**
 * Classe criada para receber as informações enviadas pelo
 * SenderInputStreamIterator. 

 * 
 * Oquê acontece na verdade é que esta classe pergunta diz: Tem mais? Então
 * manda!
 * 
 * @author Clayton.Passos
 * 
 */
public class ReaderInputStreamIterator implements Iterator {
    private static final int BUFFER_SIZE = 1;
    private DataInputStream dataIn;
    private DataOutputStream dataOut;
    private byte[] buffer = new byte[BUFFER_SIZE];

    /**
     * 
     * @param in
     *            Canal de comunicação de entrada de dados, utilizado para pedir
     *            mais informações para o SenderInputStreamIterator através do
     *            hasNext(). Também é utilizado pelo next() par ler as
     *            informações que o SenderInputStreamIterator está enviando.
     * 
     * @param out
     *            Canal de comunicação utilizado para pedir mais informações ao
     *            SenderInputStreamIterator
     */
    public ReaderInputStreamIterator(InputStream in, OutputStream out) {
 this.dataIn = new DataInputStream(in);
 this.dataOut = new DataOutputStream(out);
    }

    public boolean hasNext() {
 try {
     // Tem mais informações/bytes?
     dataOut.writeByte(TransferProtocol.hasNext);
     byte hasNext = dataIn.readByte();

     switch (hasNext) {
     case TransferProtocol.yesHasNext:
  return true;
     case TransferProtocol.noHasNext:
  return false;
     default:
  throw new IllegalStateException("TransferProtocol unexpected");
     }

 } catch (Exception e) {
     throw new IllegalStateException(e);
 }
    }

    public Object next() {
 try {
     // Se tem mais informações/bytes? Então manda.
     dataIn.readFully(buffer);
     return buffer;
 } catch (Exception e) {
     throw new IllegalStateException(e);
 }
    }

    /**
     * Not implemented, and in real case... you don´t implement this method
     */
    public void remove() {
 throw new IllegalStateException("Not implemented");
    }
}

/**
 * Classe destinada a enviar as informações contida no InputStream para a saída
 * de dados sob demanda. 

 * Oquê acontece na verdade é que esta classe fica esperando a
 * ReaderInputStreamIterator perguntar: Tem mais?
 * 
 * 

 *  Dialogo:
 *  Reader: Tem alguma coisa ai pra mim? Tem mais?
 *  Sender: Tenho, Toma!
 * 
 * 
 * @author Clayton.Passos
 * 
 */
public class SenderInputStreamIterator implements Iterator {
    private static final int BUFFER_SIZE = 1;
    private DataInputStream dataIn;
    private DataOutputStream dataOut;
    private int bytesRead;
    private byte[] buffer = new byte[BUFFER_SIZE];
    private ByteArrayInputStream byteArrIn;

    /**
     * 
     * @param in
     *            Canal de comunicação para que o hasNext saiba que o
     *            ReaderInputStreamIterator está pedindo mais informações
     * @param out
     *            Canal de comunicação para que o next() possa enviar a
     *            informação
     * 
     * @param byteArrIn
     *            informações a serem enviadas e recebidas pelo
     *            ReaderInputStreamIterator
     */
    public SenderInputStreamIterator(InputStream in, OutputStream out,
     ByteArrayInputStream byteArrIn) {
 this.dataIn = new DataInputStream(in);
 this.dataOut = new DataOutputStream(out);
 this.byteArrIn = byteArrIn;
    }

    public boolean hasNext() {
 try {
     // Reader está pedindo mais informações/bytes?
     byte hasNext = dataIn.readByte();
     if (hasNext == TransferProtocol.hasNext) {
  bytesRead = byteArrIn.read(buffer);
  // Se tem, então avisa que tem
  if (bytesRead != -1) {
      dataOut.write(TransferProtocol.yesHasNext);
      dataOut.flush();
      return true;
      // Se não tem, então avisa que não tem
  } else {
      dataOut.writeByte(TransferProtocol.noHasNext);
      dataOut.flush();
      return false;
  }

     } else {
  throw new IllegalStateException("TransferProtocol unexpected");
     }

 } catch (Exception e) {
     throw new IllegalStateException(e);
 }
    }

    public Object next() {
 try {
     // Manda mais informações/bytes
     dataOut.write(buffer);
     dataOut.flush();
 } catch (Exception e) {
     throw new IllegalStateException(e);
 }
 return buffer;
    }

    /**
     * Not implemented, and in real case... you don´t implement this method
     */
    public void remove() {
 throw new IllegalStateException("Not implemented");
    }
}

Campos de banco X Hibernate

Como saber o nome da coluna utilizada no banco de dados no mapeamento do hibernate, em tempo de execução?

Como saber o nome da tabela utilizada para persistir uma entidade?


Configuration cfg = new Configuration().configure();
SessionFactory factory = cfg.buildSessionFactory();

// através do Configuration
PersistentClass classMapping =
cfg.getClassMapping("com.entity.Usuario");

String tableName = classMapping.getTable().getName();
System.out.println("Nome da tabela: " + tableName);

Column column2 = classMapping.getTable().getColumn(2);
System.out.println("Nome da 2ª coluna: " + column2.getName());

Chave primaria hibernate

Como saber qual é a propriedade referente a chave primária e um objeto utilizando hibernate?

Configuration cfg = new Configuration().configure();
SessionFactory factory = cfg.buildSessionFactory();
 
//através do Configuration
PersistentClass classMapping = 
cfg.getClassMapping("com.model.entity.Usuario");

System.out.println("chave: " +classMapping .getIdentifierProperty().getName());

KeyValue identifier = classMapping.getIdentifier();
Iterator columnIterator = identifier.getColumnIterator();
while(columnIterator.hasNext()){
 Column cl = (Column) columnIterator.next();
 System.out.println("chave: " +cl.getName());
}


//Através da Factory
ClassMetadata classMetadata =
 factory.getClassMetadata("com.model.entity.Usuario");

System.out.println("chave: "
+ classMetadata.getIdentifierPropertyName());

Compactar e descompactar

Classe utilitária para compactar e descompactar arquivos zip apartir de um stream de dados

/**
 * Compact and Unpack Zip files
 * 
 * @author Clayton.Passos
 * 
 */
public class Zip implements ICompactOperation {
    private static final int BUFFER_SIZE = 1024;

    /**
     * Compacta os arquivos da lista armazenando-os no output
     * 
     * @param fileLst
     *            List
     * @param dataOut
     * 
     * @param pathComplete
     *            Se for verdadeiro guardará todo o caminho até o arquivo

     *            Se for falso armazenará apenas o arquivo, sem o caminho
     * @throws IOException
     */
    public static void compact(List fileLst, DataOutputStream dataOut,
     boolean pathComplete) throws IOException {
 ZipOutputStream out = new ZipOutputStream(dataOut);
 out.setLevel(9);

 // Create a buffer for reading the files
 byte[] BUFFER = new byte[BUFFER_SIZE];

 // Compress the files
 FileInputStream in;
 File file;
 for (int i = 0; i < fileLst.size(); i++) {
     file = (File) fileLst.get(i);
     in = new FileInputStream(file);

     // Add ZIP entry to output stream.
     ZipEntry entry;
     if (pathComplete) { // Complete path in zip file
  entry = new ZipEntry(file.getPath());
     } else {// only file in zip file, no path
  entry = new ZipEntry(file.getName());
     }

     out.putNextEntry(entry);

     // Transfer bytes from the file to the ZIP file
     int len;
     while ((len = in.read(BUFFER)) > 0) {
  out.write(BUFFER, 0, len);
  out.flush();
     }

     // Complete the entry
     out.closeEntry();
     in.close();
 }

 // Complete the ZIP file
 out.close();
    }

    /**
     * Descompacta o arquivo no local definido por outFilesPath
     * 
     * @param dataIn
     * 
     * @param outFilesPath
     *            Local onde ficarão os arquivos
     * @throws IOException
     */
    public static void unpack(DataInputStream dataIn, String outFilesPath)
     throws IOException {
 ZipInputStream zis = new ZipInputStream(dataIn);
 ZipEntry zipEntry = null;
 byte[] BUFFER = new byte[BUFFER_SIZE];
 String path;
 while ((zipEntry = zis.getNextEntry()) != null) {
     path = outFilesPath + File.separator + zipEntry.getName();

     // if don´t exist, create this path
     new File(new File(path).getParent()).mkdirs();

     FileOutputStream fileOut = new FileOutputStream(path);
     int count;
     while ((count = zis.read(BUFFER, 0, BUFFER_SIZE)) != -1) {
  fileOut.write(BUFFER, 0, count);
     }
     fileOut.close();

 }
 zis.close();
    }
}

Como ativar windows XP

Só pra mim não perder esse texto :D



1. Vá em Iniciar > Executar

2. Digite regedit e clique em OK.

3. Já dentro do regedit, navegue até a chave:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WindowsNT\CurrentVersion\WPAEvents
4. No painel à direita, clique duas vezes em OOBETimer

5. Na janela que foi aberta, apague qualquer valor e clique em OK. Feche o regedit
6. Vá novamente em Iniciar > Executar e dessa vez digite:
%systemroot%\system32\oobe\msoobe.exe /a

7. Na janela que foi aberta, escolha a opção Sim, desejo telefonar…

8. Na próxima etapa, clique no botão Alterar chave de produto.

9. Na etapa seguinte, digite a CD-Key:
THMPV-77D6F-94376-8HGKG-VRDRQ
e clique no botão Atualizar

10. Após clicar no botão Atualizar, o assistente para ativação voltará para a janela anterior, então, clique em Lembrar mais tarde e reinicie o Windows.

11. Reiniciado o Windows vá novamente em Iniciar > Executar e digite:
%systemroot%\system32\oobe\msoobe.exe /a

12. Aparecerá a seguinte mensagem:

Ativação do Windows
O Windows já está ativado. Clique em OK para sair

BusinessDelegate X Session Facade

Encontrei esse texto em algum lugar, não sei onde, mas achei bastante interessante....


O Facade e o Delegate tem muitas semelhanças, na maiora dos sistemas q conheço o mesmo objeto tem faz o papel dos dois. Um delegate por natureza é um Facade.

A diferença mais significativa entra Delegate e Facade, é que o Delegate abstrai a complexidade da chamada de métodos de negócio. Enquanto que o Facade é para abstrair a complexidade de um fluxo, ou workflow.
Delegate vc usa sempre para chamar um BO.
Facade vc usa quanto precisa disponibilizar uma forma simples de acessar vários métodos de negócio. Por exemplo: inserir usuário e enviar e-mail. São duas operações, mas para que os objetos clientes não precisem conhecer dois BOs("Criador de usuários"e "enviador de mail") e usado um Facade. Assim o cliente conhece apenas um metodo do Facade, e não se preocupa em como funciona a camada de negócios.
Cliente == Interface gráfica, camada controle, ou qq outra traquitana q acesso Busines Objects(BO).

Resumindo:
Delegate: Abstrai para o clinete, detalhes de como é implementado um Objeto de Negócio.
Facade: Abstrai para o cliente a compexidade entre workflow de Objetos de Negócio

Links para os dois patterns:
http://java.sun.com/blueprints/corej2eepatterns/Patterns/BusinessDelegate.html
http://java.sun.com/blueprints/corej2eepatterns/Patterns/SessionFacade.html

Livro e mais livros para download

http://www.ebook3000.com
http://downloadebookz.info
http://www.ebooksocean.com/

http://booksforpeople.sharedaa.com/
http://www.dbebooks.in/
http://ebooksbyte.com/
http://www.free-ebooks-library.com/


http://ebooksgratis.com.br/
http://ebooksgratis.com.br/category/revistas-mensais-e-mensais/arquitetura-e-urbanismo/


Nestes links, além de livros, você encontrará os chamados "video trainer", que nada mais são do que aulas em forma de video
http://downeb.com/
http://downea.info/
http://raload.com/
http://www.netbks.info/
http://booktraining.org/
http://www.netbks.com
booktraining.co
http://ranxo.com/
http://knowfree.net
http://sevno.info/
http://www.free-ebook-download.net/

Scrum

"Nossa história no início foi bem parecida com as histórias tradicionais. Sabe aquelas empresas que gastam uma semi-fortuna com uma consultoria para desenhar um processo de desenvolvimento de software? Assim estávamos nós no início de 2007. Poucos projetos eram entregues nas datas acordadas e muitos deles falhavam ou não satisfaziam as necessidades dos clientes. Contratar uma grande consultoria de software parecia ser uma boa tentativa de arrumar as coisas, mas o resultado do trabalho foi um documento que descrevia um processo com algumas centenas de páginas que devia ser seguido á risca, isso sem contar as dúzias de documentos padrão para todos os tipos de requisição e comunicação que se possa imaginar. Dezenas de páginas descreviam quem deveria falar com quem e quem entrega qual documento em qual momento. O processo foi feito para lidar com todas as complexidades, burocracias e exigências que nós mesmos criamos dentro da empresa."


Se você sentiu alguma identificação com esta estória, então leia o restante....

http://www.infoblogs.com.br/view.action?contentId=36535
http://blog.fragmental.com.br/2007/08/15/introduzindo-agilidade-num-ambiente/

Um pouco sobre internacionalização

Um pouco sobre internacionalização



Internacionalização também é conhecida por i18n devido as dezoito letras que estão entre a primeira e a última da palavra inglesa internationalization, é uma técnica utilizada para desenvolver softwares de maneira que o mesmo possa ser facilmente traduzido a outras línguas. Mas não só isso, um software internacionalizado deve ser adaptável o suficiente para se adequar a características regionais, legais, culturais e técnicas, tais como fuso horário, formato de números, datas, sistemas métricos e moedas. Este processo pode ser automático, ou manual.


Como há diferenças entre as diversas línguas “irmãs” como é o caso do português de Portugal e o do Brasil, é recomendável especificar estas diferenças. Para isto utiliza-se o l10n (da palavra inglesa localization) em conjunto do i18n, evidentemente os dois são complementares. O i10n adiciona características especificas de uma região.

Analogamente, quando criamos um objeto Locale desta forma:

Locale ptBR = new Locale(“pt”, “BR”);


Estamos dizendo que nossa língua é o português, mas que esta língua é especifica para o local Brasil. Mas, claro, se quisermos definir apenas a língua (i18n) podemos utilizar o construtor que recebe apenas a língua, como a seguir:

Locale pt = new Locale(“pt”);

Um software internacionalizado normalmente vem com um ou vários arquivos texto. Estes devem seguir o seguinte padrão:

MyResources.properties
MyResources_fr.properties
MyResources_fr_CH.properties
MyResources_pt_BR.properties
MyResources_en.properties

Para o arquivo de mensagens da listagem 6 ser reconhecida pela classe ResouceBundle, este deve seguir este mesmo padrão (nome + _ + língua + _ + pais + . + properties), ficando assim:

messages_pt_BR.properties
messages_enproperties

Caso não seja definida um Locale para o ResourceBoundle, este irá utilizar o que ele detectar que normalmente é o disponibilizado pelo Sistema Operacional.

Consulte a API de ResourceBundle para maiores detalhes.

Hibernate Validator

Hibernate Validator

A base para o JSR 303: Bean Validation.

Autor
Clayton K. N. Passos (netstart[@]gmail.com): Viciado em tecnologia. Atualmente trabalha como Desenvolvedor/Analista Pleno. (http://japz-j.blogspot.com)

A validação de dados pode e deve ser um processo centralizado e flexível o bastante para ser desempenhando em diferentes camfadas de um sistema, mas de forma centralizada. Utilizando o Hibernate Validator, inspiração para a JSR 303, isto pode ser uma tarefa simples.

Introdução
Validação de dados é uma tarefa comum, muitas vezes implementada em diferentes camadas, de diversas maneiras e até mesmo separado do framework de validação, consumindo tempo e causando erros difíceis de serem encontrados pela falta de centralização dos interesses (concerns).
Vários projetos vêm implementando e apresentando suas idéias no que diz respeito à validação de dados, entre eles: Struts, Spring e Hibernate. Neste artigo falaremos sobre a forma proposta pelo Hibernate 3, que é uma das inspirações para a JSR 303, uma das novas especificações prevista para o Java 7.
Nas primeiras versões do Hibernate 3, a API de validação estava junto do sub-projeto Hibernate Annotations, mas no momento da escrita deste artigo esta API encontra-se separada e leva o nome Hibernate Validator. Vale ressaltar que para a validação dos recursos aqui apresentados, utilizamos as próprias classes de teste do Hibernate Validator com algumas pequenas modificações e também os softwares e APIs nas seguintes versões:

· Hibernate Validator 3.0.0.GA;
· Hibernate Core 3.2.4.GA;
· Hibernate-Annotations 3.3.0.GA
· Eclipse 3.2.2;
· Java 1.6.0_01-b06.

Hibernate Validator

Seguindo o princípio da filosofia DRY (Don’t Repeat YourSelf), o Hibernate Validator trás uma forma de adicionar regras para validação automática de dados, de maneira que estas validações sejam implementadas uma e somente uma vez em toda a aplicação, eliminando a duplicação destas regras entre as diversas camadas (presentation, data access, database schema).

Utilizar annotations para adicionar regras é bastante conveniente e elegante, com elas podemos definir várias regras diretamente no modelo de classes persistente. O Hibernate Validator (H.V.) possuí algumas validações comuns (@NotNull, @Email, @Max, @Length, entre outras), mas não prende o desenvolvedor, possibilitando, a criação de validações personalizadas e internacionalizadas.

Cada annotation é associada a uma implementação de validação, que verifica se a instancia da entidade obedece a sua regra. O Hibernate faz isto automaticamente antes de um insert ou update, mas você também pode chamar a validação a qualquer momento em sua aplicação e de qualquer Java Persistence provider (JPA).

As validações podem ser utilizadas em dois níveis: aplicação e banco de dados. A primeira traz a possibilidade de validar a instancia de classes através de suas regras em tempo de execução (veja o quadro de constraints), enquanto que a segunda é incorporada ao Hibernate metamodel e ao database schema gerado, traduzindo as regras que você adicionou no mapeamento de suas entidades. Por exemplo, se você adicionar @NotNull a uma propriedade de sua entidade, a coluna irá ser declarada como not null no DDL schema gerado pelo Hibernate (hbm2ddl). Caso você não queria mais este comportamento, basta atribuir false a hibernate.validator.apply_to_ddl.
Este artigo está focado na primeira forma de validação.


Constraints

Aqui você pode ver uma lista de algumas regras que podem ser adicionadas a suas entidades, de maneira que o hibernate possa validar as informações armazenadas dentro delas. Lembre-se de que estas são constraints que o Hibernate Validator fornece para nós trabalharmos, mas podemos definir as nossas constraints personalizadas. Mas o que são constraints?Em poucas palavras: Constraints são regras de restrição, e sua semântica é definida pelas annotations que a descrevem.

Annotation Funcionalidade
@Length(min=, max=): Verifica se o tamanho da string esta dentro dos limites.

@Max(value=): Verifica se o valor é maior ou igual. Aplicado a representações de números, armazenados até mesmo em String.

@Min(value=): Verifica se o valor é menor ou igual. Aplicado a representações de números, armazenados até mesmo em String.

@NotNull: Checa se o valor não é null.

@NotEmpty: Checa se não é null e não vazia.

@Past: Checa se uma data esta no passado.

@Future: Checa se uma data esta no futuro.

@Pattern(regex=”regexp”, flag=)ou@Patten({@Pattern(...)}): Checa se a propriedade obedece à expressão regular.

@Range(min=, max=): Confere se o valor está entre o mínimo e o máximo (incluindo), aplicado a valores numéricos, mesmo armazenados em String.

@Size(min=, max=): Confere se a quantidade de elementos esta entre o mínimo e o máximo (incluído), aplicado a Array, Collection, Map.

@AssertFalse: Confere se o valor de uma propriedade boolean é false.

@AssertTrue :Confere se o valor de uma propriedade boolean é true

@Valid: Impõe uma validação recursiva aos objetos associados. Se o objeto é uma Collection, Map ou um Array, os elementos são validados recursivamente.

@Email: Confere se a string é um e-mail válido.

@CreditCardNumber: Confere se a string é um número de cartão de crédito válido.

@Digits: Verifica quantidade de dígitos ante e depois do separador de casa decimal (integerDigits e factionalDigits).

@EAN: Verifica se a string é um código EAN ou UPC-A válido



Como utilizar o framework?
É chegada a hora de “sujarmos as mãos” e ver como a teoria se aplica na prática. Lembre-se de que se você estiver utilizando o Hibernate como uma solução para o Mapeamento Objeto Relacional (ORM), a integração do Hibernate Core com o Hibernate Validador é transparente. As validações ocorrem sempre antes de qualquer insert ou update, caso haja algum erro será disparado uma exceção com as regras violadas. Se por algum motivo for necessário desabilitar a esta integração basta atribuir false a hibernate.validator.autoregister_listeners.

Para começar vamos criar uma classe que servirá apenas para nos mostrar os erros de uma forma mais amigável. Chamaremos esta classe de HandlerTest e seu propósito de existência é o de imprimir na saída padrão as mensagens de erro, se tiver alguma, caso contrário deverá nos avisar de que não há nenhum erro, veja a listagem 1.

Analisando o código, vemos que a classe HandlerTest verifica se o array de InvalidValue é igual a 0, esta é a forma da qual você pode ter certeza de que não nenhum erro foi detectado pelo Hibernate Validator, pois, sempre que for detectado um erro, haverá algum elemento no array retornado pelo validador. Caso o array invalidValues tenha algum elemento o código da listagem 1 chama o método print() para nos mostrar o quê tem dentro do array. Veja o quadro InvalidValue para saber a utilidade dos principais métodos desta classe.

Listagem 1: Classe HandlerTest
public class HandlerTest {
 public static void printErrors(InvalidValue[] invalidValues) {
  System.out.println("** Listagem de erros **");
  if (invalidValues.length == 0) {
   System.out.println("Oba! Não há erros!\n");
  } else {
   print(invalidValues);
  }
 }

 private static void print(InvalidValue[] invalidValues) {
  Class clazz = invalidValues[0].getBeanClass();
  System.out.print("Há " + invalidValues.length);
  System.out.println(" erro(s) na entidade: " + clazz.getSimpleName());
  for (InvalidValue iv : invalidValues) {
   System.out.print("A propriedade ");
   System.out.print(iv.getPropertyName());
   System.out.println(" possui o seguinte erro: ");
   System.out.println(iv.getMessage());
   if (iv.getValue() != null) {
    System.out.print("Valor errado: ");
    System.out.println(iv.getValue());
   }
  }
 }
}

InvalidValue
GetBeanClass(): Retorna o tipo da classe que provocou o erro.

getBean(): Retorna a instancia da classe que falhou na validação.

getMessage(): Retorna a mensagem de erro, que pode estar internacionalizada.

getValue(): Retorna o valor errado.


Como já dissemos, você pode validar as informações contidas em suas entidades, em qualquer lugar do sistema. A maneira de fazer isto é chamando o método getInvalidValues da classe ClassValidator, se houver algum erro na entidade ele retornará um array de InvalidValue contendo diversas informações pertinentes a este erro. Simples, não?

Agora que já temos uma maneira simples de verificar as validações, vamos a um caso de uso fictício, suponha que para a compra de um carro o mesmo deve obedecer a dois critérios, seu IPVA deve estar pago e livre de amassados. Definimos classe Car utilizando as Annotations @AssertTrue e @AssertFalse de maneira que a propriedade ipvaPago seja igual a true, e que a propriedade amassado seja igual a false, veja a listagem 2.

Listagem 2: Classe Carro

public class Carro{
 String cor;
 @AssertTrue
 boolean ipvaPago;
 @AssertFalse
 boolean amassado;
}

Na listagem 2 podemos observar que as constraints foram adicionadas em cima da propriedade, uma alternativa caso seja necessário é definidas sobre o método get da respectiva propriedade. Particularmente não gostamos de definir as regras em cima dos métodos getXX(), pois torna o código menos intuitivo e menos legível, aconselhamos que sempre utilize a propriedade para adicionar as constraints.

Acompanhe na listagem 3, que a classe AssertTest imprimirá primeiramente dois erros, mas posteriormente, como não será detectado nenhum erro pelo validador, apenas haverá uma mensagem confirmando que as informações contidas na entidade são válidas. Como não definimos nada no código referente a língua, as mensagens de erros virão na língua configurada no Sistema Operacional. Até o momento da escrita deste artigo, eram onze as línguas suportadas, entre elas: português do Brasil; inglês; espanhol; italiano; francês; chinês e alemão.

Lista 3: Classe AssertTest

public class AssertTest {
 public static void main(String[] args) {
  Car fuscao = new Car();
  fuscao.cor = "preto";
  fuscao.ipvaPago = false;
  fuscao.amassado = true;

  ClassValidator classValidator = new ClassValidator(Car.class);
  InvalidValue[] invalidValues = classValidator.getInvalidValues(fuscao);
  printErrors(invalidValues);

  fuscao.ipvaPago = true;
  fuscao.amassado = false;
  invalidValues = classValidator.getInvalidValues(fuscao);
  printErrors(invalidValues);
 }
}

Definindo suas próprias validações

Criar nossas próprias validações é muito simples, é necessário apenas duas coisas, criar uma Annotation que descreva a regra e criar uma classe que implemente a interface org.hibernate.validator.Validator (veja a listagem 4 e 5), feito isto é só adicionar a Annotation a sua entidade para que ela seja validada.

Listagem 4: Annotation Phone

@ValidatorClass(PhoneValidator.class)
@Target({FIELD, METHOD})
@Retention(RUNTIME)
@Documented
public @interface Phone {
 String ddd() default "44";
 String message() default "{validator.phone}";
}

Na listagem 4, podemos acompanhar o código de uma Annotation destinada a validação de telefones. Três pontos importantes devem ser observados nesta classe. Na primeira linha temos a anotation @ValidatorClass dizendo que é utilizado a classe PhoneValidator como a implementação que irá validar a entidade anotada com @Phone. Os dois próximos pontos importantes são as propriedades ddd e message. Ambas podem ser mudadas no momento de definir uma entidade da seguinte forma:
@Phone(ddd = “45”, message = “mensagem de erro”)

A propriedade message tem propósito especifico, que é armazenar uma string que será utilizada caso um erro proveniente desta Annotation seja detectada. No exemplo, o valor default é {validator.phone}, uma mensagem nada inteligível, mas aliado ao recurso de internacionalização ela será, pois com esta chave o mecanismos de internacionalização do Hibernate Validator tentará encontrar a mensagem apropriada, caso não encontre será utilizado a string {validador.phone} na integra.

A classe PhoneValidator mostrada na listagem 5, possuí apenas dois métodos reescritos da interface Validator. Enquanto o método initialize(Phone parameters) recupera os valores atribuídos na entidade para a annotatoin @Phone o método isValid(Object value) faz o trabalho de verificar se o conteúdo da propriedade é valido, atente para o parâmetro que isValid recebe, esta é a informação que deve ser validada. Em nosso código de exemplo para um telefone ser válido é preciso estar no formado (44)0000-0000 (DDD 44 entre parênteses, seguido de quatro números, um traço e novamente quatro números).

O Hibernate Validator utiliza a classe ResourceBundle para internacionalizar as mensagens de erros. É bastante tranqüilo trabalhar com ela, primeiramente precisamos de um arquivo .properties, dentro dos padrões (veja o quadro: Um pouco sobre internacionalização); a Annotation precisa estar preparada para trabalhar com a mensagem internacionalizada e que seja explicitado que utilizaremos o arquivo específico para as mensagems.

Na listagem 6, temos um código completo, que imprime a mesma mensagem de erro em duas línguas diferente. Para isto foram necessárias apenas algumas linhas de código adicionais, veja que foi preciso passar no segundo parâmetro do construtor de ClassValidator um ResouceBundle que foi criado apartir de um Locale.

É possível sobrescrever as mensagens padrão do H.V., a regra é simples. Dentro do arquivo que você armazena as mensagens internacionalizadas, você adiciona a chave validator.nomedaannotation. Por exemplo, para mudar a mensagem da annotation @NotNull haverá no arquivo a seguinte chave:
validator.notnull=Erro, a propriedade não pode ser null

Se for necessário informar os valores permitidos, como é caso de @Length, podemos colocar o nome da variável entre chaves, desta forma, esta será trocada automaticamente pelo valor configurado na entidade. Veja o exemplo a seguir:
validator.length=Xii!! Deu erro no Length, os valores devem estar entre {min} e {max}

Listagem 5: Classe PhoneValidator

public class PhoneValidator implements Validator {
 private String dddValid;
 public void initialize(Phone parameters) {
  dddValid = parameters.ddd();
}

 public boolean isValid(Object value) { 
  if (value == null) {
   return true;
  }

  String phone = (String) value;
  //(44)9962-3019
  String reg = "\\(" +dddValid+ "\\)[0-9]{4}\\-[0-9]{4}";
  Pattern pattern = Pattern.compile(reg);
  Matcher match = pattern.matcher(phone);
  return match.matches();
 }
}

Listagem 6: Classe PhoneTest

public class PhoneTest {
 public static void main(String[] args) {
  HomePhone hPhone = new HomePhone();
  hPhone.phone = "3366-3330";

  Locale ptBR = new Locale("pt", "BR");
  ResourceBundle rBundleDefault = ResourceBundle.getBundle("messages", ptBR);
  ResourceBundle rBundleEnglish = ResourceBundle.getBundle("messages", Locale.ENGLISH);
  ClassValidator classValidator;
  classValidator = new ClassValidator(HomePhone.class, rBundleEnglish);
  InvalidValue[] invalidValues = classValidator.getInvalidValues(hPhone);
  printErrors(invalidValues);
 
  classValidator = new ClassValidator(HomePhone.class, rBundleDefault);
  invalidValues = classValidator.getInvalidValues(hPhone);
  printErrors(invalidValues);

  hPhone.phone = "(44)9962-3019";
  invalidValues = classValidator.getInvalidValues(hPhone);
  printErrors(invalidValues);
 }
}

Não se preocupe

O Hibernate Validator cuida de vários problemas comuns do desenvolvimento de software. Referencia circular, muito discutido no quesito qualidade de software, é um destes problemas, este tipo de situação, comum, levou a alguns brasileiros criarem um pluguin para o Eclipse chamado ByeCycle que auxilia a eliminar referencias circulares. Acompanhe pela listagem 7 que a entidade Contact nos diz que a entidade Brother também deve passar pela validação (@Valid), mas a Classe Brother faz o mesmo para com a classe Contact, isto poderia facilmente levar a um problema sério de referencia circular, mas isto não é algo do qual devemos nos preocupar, pois o H. V. sabe lidar com esta situação perfeitamente, nos permitindo usar estas classes.

Listagem 7: Referencia circular

public class Contact {
  @NotNull
  public String phone;
  @Valid
  public Brother brother;
}

public class Brother {
  @NotEmpty
  public String name;
  @Valid
  public Contact contact;
}

É possível validar todos os elementos de uma Collection ou array facilmente, não é necessário nenhum recurso “informágico”. Basta adicionar a Annotation @Valid a estrutura que esta terá todos os seu itens validados. Acompanhe a listagem 8 que demonstra como uma classe TV pode ter o seu Map de Show verificado item a item pelo Hibernate Validator.

Listagem 8: iterable

public class Tv {
  @NotNull
  public String name;
  @Valid
  public Map shows = new HashMap();
}
public class Show {
  @NotNull
  public String name;
}

Esta poderosa ferramenta nos permite também agregar várias expressões regulares, para validar uma única propriedade, acompanhe a listagem 9, observe que definimos duas E.R. e também personalizamos as mensagens que serão utilizadas para informar o usuário caso alguma destas regras sejam desrespeitadas.

Listagem 9: agregando E.R.

@Patterns( {
     @Pattern(regex = "^[A-Z0-9-]+$", message = "must contain alphabetical characters only"),
     @Pattern(regex = "^....-....-....$", message = "must match ....-....-....") }
)

Integração com Hibernate
A utilização do Hibernate (core) propriamente dito em conjunto com o Hibernate Validator é feita através do Hibernate Annotation (ou Hibernate EntityManager) e neste caso a validação será automática, não será necessário nenhum código para chamar o validador, pois esta chamada ocorrerá antes de qualquer inserção de dados novos ou alterações (save ou update).

Para verificar este comportamento foi criado uma entidade chamada Linha, a ela demos alguns atributos e algumas regras para serem verificadas, como por exemplo @NotNull e @Length(max = 100). Também foram criadas as classes HibernateUtil e LinhaTeste, classes utilizadas para nos fornecer a Session e testar o comportamento de validação respectivamente.

Após a execução do teste dois tipos de exceções foram lançadas: org.hibernate.PropertyValueException e org.hibernate.validator.InvalidStateException ambas indicando problemas encontrados pelo Hibernate Validator, veja a listagem 11 e 12 para verificar um pequeno trecho da exceção.

Não é recomendável mas caso seja necessário, é possível desligar a pré validação atribuindo false a variável de configuração:
hibernate.validator.autoregister_listeners

Listagem 10: Classe LinhaTeste

public static void main(String[] args) {
 Linha linha = new Linha();
 linha.setIdLinha(new BigDecimal(10));
 Session session = HibernateUtil.getSession();
 session.getTransaction().begin();
 session.save(linha);
 session.getTransaction().commit();
 HibernateUtil.getSession().close();
}

Listagem 11: exceção lançada pela validação do Hibernate
Exception in thread "main" org.hibernate.PropertyValueException: not-null property references a null or transient value: org.hibernate.validator.test.hibernateIntegracao.Linha.codigo
...

Listagem 12: exceção lançada pela validação do Hibernate
Exception in thread "main" org.hibernate.validator.InvalidStateException: validation failed for: org.hibernate.validator.test.hibernateIntegracao.Linha
...

Camada de apresentação

JBoss Seam é um poderoso framework para a construção de aplicações Web 2.0, unificando e integrando tecnologias como: AJAX, JSF, EJB3, Java Portlets e BPM. Este projeto é desenhado para eliminar a complexidade destas arquiteturas, de maneira a possibilitar os desenvolvedores criar aplicações web simplesmente anotando classes POJOs [7].

JavaServer Faces é um framework MVC, também para desenvolvimento de aplicações Web, que permite o desenvolvimento de aplicações para internet ao estilo Delphi, (arrastando e soltando). Considerado por muitos, a última palavra em desenvolvimento Web, resultado obtido pela maturidade de tecnologias como JSP/Servlet (Model1), Model2 (MVC) e Struts.

Trabalhando juntas, as tecnologias JSF e JBoss SeamÔ pode-se disparar o processo de validação até a camada de apresentação usando as tags e , desta forma, enquanto as regras são expressas no model as mensagens de erro são apresentadas na view, sem duplicação para o usuário, um exemplo de utilização desta tag encontra-se na listagem 13, veja também documentação do JBoss SeamÔ para maiores detalhes.

Listagem 13: visualizando as mensagens de erro com JSF

< s:validateAll>
 < div>
  Telefone:
  < h:inputText value="#{validator.phone}" required="true" />
 < /div>
< /s:validateAll>

JSR 303: Bean Validation
Bean Validation, já aprovada e prevista para a versão 7 do Java, deverá padronizar a definição de validadores, regras de validação e afins. Baseado em annotations e descritores XML, este novo recurso fornecerá em tempo de execução meios de checar e validar as propriedades de classes persistentes. Para validações mais comuns e simples, serão utilizadas annotations, enquanto casos mais complexos ou regras de negócios específicas utilizarão um descritor XML para configurar a validação [1].

Fortemente inspirada no Commons-Validator, Hibernate Validator e XWork Validation Framework, a JSR 303 poderá ser utilizada não somente em aplicações web, mas também em aplicações desktop e para a camada de persistência, permitirá o envio mensagens de erros internacionalizadas, e também a personalização através da classe ResourceBundle.

O líder deste sub-projeto (Hibernate Validator) é um dos membros da JSR 303, por isto podemos esperar que esta nova especificação do Java seja bem semelhante ao que descrevemos neste artigo.


Considerações Finais

Consistência de dados, testes e validação, são itens dos quais todos precisamos, mais cedo ou mais tarde a esta necessidade “bate nossa porta”, é nesta hora que precisamos tomar a decisão de qual tecnologia e estratégia adotar. O Hibernate Validator fornece um tratamento bem interessante, como ela é fortemente ligada a Bean Validation, acreditamos que vale, e muito, dedicar algumas horas para a pesquisa e aprendizado deste recurso, não somente porque é algo que está por vir no Java 7, mas porque este tende a ser um padrão no desenvolvimento de aplicações.

Para facilitar a vida do leitor, está disponível para download um projeto eclipse com os fontes utilizados para validar as informações contidas neste material. Nele você encontrara exemplos de validações, incluindo até mesmo algumas que não foram extensivamente exploradas neste texto. É importante ressaltar que muitos dos códigos foram retirados ou modificados dos próprios testes unitários (JUnit) do Hibernate Validator, por isto, caso o leitor queira ter acesso aos originais basta buscar direto na fonte.


Referências

[1] JSR 303: Bean Validation http://jcp.org/en/jsr/detail?id=303
[2] Hibernate - http://www.hibernate.org
[3] Commons-Validator - http://jakarta.apache.org/commons/validator
[4] XWork Validation Framework - http://wiki.opensymphony.com/display/XW/Validation+Framework
[5] API da classe ResourceBundle
[6] Internacionalization support - http://java.sun.com/javase/6/docs/technotes/guides/intl/index.html
[7] http://www.jboss.com/products/seam

Oque é ser programador?

Ser um programador nada mais é doque um transformador, assim como uma planta faz fotosintece(como escreve isso?) transformando agua e luz solar em seu próprio alimento, o orogramador transforma café em linhas de código

Continuous Integration

i believe that is a important paradigm....

An important part of any software development process is getting reliable builds of the software. Despite its importance, we are often surprised when this isn't done. We stress a fully automated and reproducible build, including testing, that runs many times a day. This allows each developer to integrate daily thus reducing integration problems.


http://www.martinfowler.com/articles/continuousIntegration.html

Coleção de exemplos e templates reutilizaveis com JEE 5

Now i'll indicate to you a p4j5 project, this project is a collection of samples and reusable templates which demonstrates patterns, approaches and architectural ideas for the Java EE 5 platform.


https://p4j5.dev.java.net/

http://www.adam-bien.com/tdb

SOA x ESB, oque?

Original: http://www.guj.com.br/posts/list/77933.java

Encontrei no forum uma explicação bastante clara sobre o assunto, leiam...


Pois bem. Primeira coisa que deve ser entendida sobre SOA (Arquitetura Orientada a Serviços) é que SOA não é um produto, ela é simplesmente um paradigma. Do mesmo jeito que programação orientada a objetos é um paradigma, e não um produto. Dito isso, outro ponto importante a ser levado em consideração é que SOA está na moda. Por isso você verá muitas empresas por aí (IBM, Oracle, BEA e outras) vendendo SOA, empurrando SOA para os seus clientes goela abaixo. Isso é uma enganação. SOA não é um produto e portanto não pode ser vendida. SOA é algo que você terá que implementar na prática, por si só, ou junto com a sua equipe de desenvolvimento. O que essas empresas podem lhe fornecer será no máximo algumas ferramentas, frameworks, bibliotecas para facilitar o seu trabalho.

Outro ponto importantíssimo é entender se você realmente precisa de SOA, ou seja, quando é que SOA se torna necessária de fato?

SOA é um paradigma para grandes sistemas distribuídos de proprietários e tecnologias diferentes! Se este não for o seu caso, você não precisa de SOA!

Voltando agora para a sua pergunta e levando em consideração as afirmações acima:

O que é um ESB (Enterprise Service Bus)?

Nada melhor para explicar um conceito "novo" do que através de um exemplo. Suponha a seguinte situação. Uma empresa X possui um sistema de grande porte desenvolvido em Java (JEE, EJB e outros). Essa empresa X adquire uma empresa Y que por sua vez utiliza tecnologia .NET. A empresa possui um sistema de CRM que necessita, por alguma motivo, obter informações dos dois sistemas para que possa fazer algum processo de atendimento ao cliente. Para fazer isso você teria várias opções, poderia conectar os dois sistemas diretamente, poderia desenvolver uma classe (ou todo um pacote de classes) que faça acesso aos dois sistemas.

Com tempo, à medida que surgissem outras necessidades de conectar esses dois sistemas, você acabaria por ter uma confusão geral de sistemas acessando outros sistemas. Um caos de verdade. Para evitar isso, entra o papel de ESB, que neste caso seria um "negociador", seria uma "interface" para a qual você iria solicitar a execução de alguns processos, consultas, etc. Ou seja, um elemento intermediário que seria responsável por conectar sistemas diferentes. O seu sistema Java nem tomaria conhecimento de que o outro sistema é feito em .NET ou em qualquer outra tecnologia, porque ele se comunicaria apenas com o ESB, o qual por sua vez teria o papel de se conectar a esses outros sistemas. Resumidamente, ESB seria uma abstração dessa interconexão de sistemas que usam tecnologias diferentes.

A maneira mais comum de se implementar um ESB hoje é através de Web Services, mas isso não é regra, existem outras formas de se realizar a mesma atividade. (ESB <> Web Services).

Se ainda não está claro o que é um ESB, vamos tentar entrar mais na parte prática da coisa, vamos imaginar o que poderia ser um ESB. Ele poderia muito bem ser um sistema "independente" desenvolvido em .NET que disponibiliza uma séria de Web Services e que se conecta a vários backends usados pela empresa. (Usei exemplo de .NET em um fórum Java de propósito, para destacar que SOA é independente de tecnologia usada). Como Web Sevices são um padrão (tudo bem que esse padrão ainda possui diversas coisas "não padronizadas", mas é possível seguindo boas práticas e alguns padrões já estabelecidos alcançar um resultado bom), o seu sistema Java poderia se conectar a esse "ESB.NET" atráves de Web Services e obter o resultado desejado.

Só para concluir e para ficar bem claro:
SOA é um paradigma e não um produto.

Se alguém chegar dizendo que tem uma solução SOA pronta para sua empresa, isso é mentira.

ESB é o coração de uma arquitetura SOA, é o ponto de interconexão entre sistemas que usam tecnologias diferentes.

SOA está na moda, cuidado ao adquirir "produtos prontos".

Web Services são apenas uma maneira dentre outras para implementar tal arquitetura (embora de longe a mais usada).

Espero ter esclarecido para você e para outros leitores deste fórum alguns conceitos de SOA.

TESTE PARA DESCOBRIR SUA PERSONALIDADE

TESTE PARA DESCOBRIR SUA PERSONALIDADE



1. Quando você se sente melhor?
(a) pela manhã
(b) durante a tarde e final de tarde
(c) tarde da noite

2. Você normalmente caminha
(a) bastante rápido, com passos longos,
(b) bastante rápido, com passos curtos e ligeiros,
(c) menos rápido e cabeça para cima, olhando o mundo de frente
(d) menos rápido, com a cabeça para abaixo
(e) muito lentamente

3. Ao falar com pessoas você
(a) fica de puê com seus braços dobrados
(b) fica com suas mãos apertadas (fechadas)
(c) com uma ou ambas mãos em seus quadris
(d) toca ou empurra a pessoa a quem você está falando
(e) brinca com sua orelha, toca seu queixo, ou alisa seu cabelo

4. Ao relaxar, você se senta com
(a) seus joelhos dobrados juntos lado a lado com suas pernas
(b) cruza suas pernas
(c) com suas pernas esticadas ou abertas
(d) uma perna debaixo de você

5. Quando algo realmente o fizer rir, você reage com
(a) uma gargalhada,
(b) uma risada, mas não muito alta
(c) um quieto riso
(d) um sorriso embaraçado

6. Quando você vai para uma festa ou reunião social, você..
(a) faz uma entrada chamativa assim todo o mundo o nota
(b) faz uma entrada quieta, enquanto procura conhecidos
(c) faz uma entrada mais quieta, tentando ficar desapercebido

7. Você está trabalhando muito firme, muito concentrado, e te interrompem. Você:
(a) dá boas vindas à interrupção
(b) fica extremamente irritado
(c) varia entre este dois extremos

8. O qual das cores seguintes você gosta mais?
(a) vermelho ou laranja
(b) preto
(c) amarelo ou azul claro
(d) verde
(e) escuro azul ou roxo
(f) branco
(g) marrom ou cinza

9. Quando você já está na cama, nesses últimos momentos antes de ir dormir, você deita
(a) reto de costas
(b) reto de bruços
(c) em seu lado, ligeiramente curvo
(d) com sua cabeça em um braço
(e) com sua cabeça debaixo das cobertas

10. Você freqüentemente sonha que você está
(a) caindo
(b) lutando ou discutindo
(c) procurando algo ou alguêm
(d) voando ou flutuando
(e) você normalmente não tem sonhos (não lembra)
(f) seus sonhos sempre são agradáveis

PONTOS:
1. (a) 2 (b) 4 (c) 6
2. (a) 6 (b) 4 (c) 7 (d) 2 (e) 1
3. (a) 4 (b) 2 (c) 5 (d) 7 (e) 6
4. (a) 4 (b) 6 (c) 2 (d) 1
5. (a) 6 (b) 4 (c) 3 (d) 5 (e) 2
6. (a) 6 (b) 4 (c) 2
7. (a) 6 (b) 2 (c) 4
8. (a) 6 (b) 7 (c) 5 (d) 4 (e) 3 (f) 2 (g) 1
9. (a) 7 (b) 5 (c) 4 (d) 2 (e) 1
10.(a) 4 (b) 2 (c) 3 (d) 5 (e) 6 (f) 1

Agora some o número total de pontos.


MAIS DE 60 PONTOS:

Outros o vêem como alguêm que eles deveriam tomar cuidado "que você uê visto como vaidoso, egocêntrico, e que uê extremamente dominante. Outros podem o admirar, desejando que eles poderiam estar mais como você, mas não confiam sempre em você, hesitando de se tornarem muito envolvidos com você.


51 A 60 PONTOS:
Outros o vêem como uma pessoa personalidade altamente volátil, bastante impulsiva; um líder natural que uê rápido em tomar decisões, entretanto não sempre certa. Eles o vêem como tipo arrojado e aventureiro, alguêm que tentará qualquer coisa uma vez; alguêm que se arrisca e desfruta uma aventura. Eles gostam de estar em sua companhia por causa da excitação que você radia.


41 A 50 PONTOS:
Outros o vêem como vivo, encantador, divertido, prático, e sempre interessante; alguêm que constantemente está no centro da atenção, mas suficientemente sensato não deixar isto subir para a cabeça. Eles tambuêm o vêem como amável, considerado, e compreensivo; alguêm que sempre os animará e os ajudará.


31 A 40 PONTOS:
Outros o vêem como sensato, cauteloso, cuidadoso e prático. Eles o vêem como inteligente, talentoso, ou abençoado, mas modesto. Uma pessoa que não faz os amigos muito depressa ou facilmente, mas alguêm que uê extremamente leal aos amigos, e que espera a mesma lealdade em retorno. Esses que realmente conseguem sabem que é difícil abalar sua confiança em seus amigos, mas igualmente que leva muito tempo para superar isto se aquela confiança foi quebrada.


21 A 30 PONTOS:
Seus amigos o vêem como diligente e nervoso. Eles o vêem como muito cauteloso, extremamente cuidadoso. Realmente os pega de surpresa se você faz algo impulsivamente ou no afã do momento, esperando que você examinasse tudo cuidadosamente de todos os lados e então, normalmente, decide contra isto. Eles pensam que esta reação é causada em parte por sua natureza cuidadosa.


ABAIXO DE 21 PONTOS:
As pessoas pensam que você é tímido, nervoso, e indeciso, alguêm que precisa pensar mais, que sempre quer que outra pessoa tome as decisões e que não quer se envolver com qualquer um ou qualquer coisa. Eles o vêem como um preocupado que sempre vê problemas que não existem. Algumas pessoas pensam que você é enfadonho. São os que conhecem bem sabem que você não é.

Você tem raciocinio lógico?

Continue a sequência de números apresentados.

Tente fazer esse teste em cinco minutos.


1-) 1322543210, 1344543210, 1366543210,
A) 1388543211
B) 1366543211
C) 1388543210
D) 1300543210

2-) 1234567890, 6789012345, 1234567890,
A) 6789012345
B) 1234567890
C) 2345678901
D) 7890123456

3-) 1234678125, 1236784125, 1237846125,
A) 1234678126
B) 1234678125
C) 1238467125
D) 1234678251

4-) 2938204185, 3938204184, 4938204183,
A) 1938204182
B) 5938204182
C) 5938204183
D) 5938204186

5-) 5494859485, 5496959406, 5498059427,
A) 5494859448
B) 5490159427
C) 5490159448
D) 5494859485

6-) 4356787874, 4361787879, 4366787884,
A) 4361787889
B) 4351787889
C) 4377787889
D) 4371787889

7-) 4135646789, 2115444769, 6155848709,
A) 4135646789
B) 8175040729
C) 0195242749
D) 2115444769

8-) 4564310041, 4575533341, 4586756641,
A) 4597867741
B) 4597979941
C) 4597978841
D) 4597869941

9-) 4594594854, 9594594859, 9894594889,
A) 4894594854
B) 4894594884
C) 9874594789
D) 9594594859

10-) 3429857414, 3021827314, 3122837415,
A) 3220817315
B) 3323847315
C) 3428807315
D) 3223847516
















Resultado:
1=C 2=A 3=C 4=B 5=C 6=D 7=A 8=B 9=C 10=D






10 Acertos
Você é a lógica em pessoa. O que está esperando para se tornar PHD em física ou
matemática?

8/9 Acertos
Você uê extremamente lógico, pode ser um grande engenheiro ou químico.

6/7 Acertos
Bom em lógica, você está apto à informática, direito ou economia.

4/5 Acertos
Sua lógica uê regular, pode trabalhar em qualquer ramo, mas evite a área de exatas para
não sofrer.

2/3 Acertos
Lógica deficiente, mantenha distância de tudo que lembre matematica. Faça letras,
história ou geografia.

0/1 Acertos
Seu futuro é ser revolucionário, psicólogo, sociólogo, reporter ou ator. Quanto
mais viagem, melhor.



Quantos você acertou em 5 minutos?

Eu acertei 5 :( será que tenho de mudar de profissão?

Utilidade pública

Sábado , 15 de Março de 2008

Alerta ao consumidor
No dia internacional do consumidor, O Jornal Hoje faz um alerta para quem tem seguro de carro. Você pode estar sendo lesado, sem saber. O Ministério Público já comprovou o envolvimento de seguradoras em crimes como estelionato e falsificação de documentos.




Numa lista, estão alguns dos muitos consumidores lesados pelas seguradoras. O publicitário Fernando Domingos que também foi vítima de uma dessas empresas faz parte de uma ONG criada para dar voz a essas pessoas. “Eu comecei a pesquisar e quando eu comecei essa investigação eu vi que eram dezenas de pessoas que passaram a centenas e milhares de pessoas como eu”, conta.

O Ministério Público de São Paulo já comprovou a prática de diversos crimes e está processando as seguradoras por estelionato, falsificação de documento público, ameaça a consumidores, coação de testemunhas, provas forjadas e formação de quadrilha ou bando. “Os representantes de seguradoras e os policiais abordam o consumidor e deixam bem claro ou você desiste do recebimento do seguro ou então você será indiciado e processado por estelionato, porque nós temos um documento paraguaio de compra e venda do seu veículo na data que você disse que havia sido furtado”, diz o promotor José Luiz Bednarski.

Dona Maria Isabel passou por isso. Na delegacia onde foi denunciar o roubo do carro do filho foi acusada e humilhada. “Disse que eu era a chefe da quadrilha internacional”, conta.

Além desses crimes, a seguradora também lucra com a desinformação dos consumidores. Está no contrato que a franquia do seguro só precisa ser paga quando você amassar o carro. Se você bater num outro veículo o reparo dos danos desse terceiro veículo deve ser feito pela seguradora sem nenhuma franquia. Só que pouca gente sabe disso.

O presidente do sindicato das oficinas de São Paulo encaminhou várias denúncias á secretaria da Justiça. “É um círculo que tem colocado principalmente a vida do consumidor em risco”, diz.

O Jornal Hoje procurou a superintendência de seguros privados para falar sobre as acusações do Ministério Público, mas não tivemos resposta.