Classe sempre interessante do Commons-lang:
org.apache.commons.lang
public static
class ObjectUtils.Null
extends Object
implements Serializable
Kick-butt Cellulite Redux – Not Weight Loss, Not A Gym Routine
A Classe Null
p>
Leituras
Modificações concorrentes
Mesmo programando há algum tempo em Java, há excepções que nos surpreendem e nos mostram que até somos capazes de não perceber nada disto.
Um colega obtinha, por vezes, uma excepção ConcurrentModificationException ao percorrer uma lista com um iterador. O código era uma versão mais complexa do seguinte excerto:
List lista = new ArrayList();
lista.add("obj1");
lista.add("obj2");
for(Iterator it=lista.iterator();it.hasNext();) {
String elem = (String) it.next();
if("obj1".equals(elem)) {
lista.add("elem3");
}
}
O que acontecia era, se uma condição se verificasse, era removido um elemento da lista. Quando tal acontecia, a próxima vez que o método next() do iterador fosse executado, obtínhamos a excepção. Ao olhar para o nome da excepção
, a primeira ideia foi que, dado a lista não ser sincronizada, estavam threads concorrentes a aceder ao objecto. No entanto, a conclusão foi mais simples e lógica.
Quando se
altera a estrutura de uma lista – adicionando ou removendo elementos – à qual está ligado um iterador que estamos a percorrer, esse iterador fica inválido. Limita-se a verificar se fizemos operações que alterassem a lista, se sim, lança uma ConcurrentModificationException. Não que seja um nome de excepção adequado.
A este comportamento dá-se o nome de fail-fast, pois o iterador lança a excepção mal detecta que existiu uma alteração à lista e não fica à espera que ocorra um erro, não determinístico, mais tarde, ao percorrer o iterador.
De notar que o mesmo ocorre se usarmos o foreach do java 5 e removermos elementos.
Annotations – interfaces "diferentes"
Numa discussão com um amigo, surgiu o tema sobre como classificar uma annotation. Será um interface ou uma classe, visto que embora seja definido com @ interface, podemos atribuir e retirar valores da annotation, indiciando que existe uma implementação dos métodos.
Na realidade, uma annotation é um tipo de interface. Tal como todas as classes que criamos extendem implícitamente a classe Object, sempre que criamos uma annotation esta extende implícitamente o interface Annotation. O interface annotation tem a seguinte definição:
public interface Annotation { boolean equals(Object obj); int hashpre(); String toString(); Class annotationType(); }
Se quisermos criar uma nova annotation, podemos declará-la da seguinte forma:
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @ interface Teste{ String umMembro(); }
Definimos uma annotation de teste com um membro do tipo String. Definimos com a Retention que a annotation vai estar disponível em runtime, e definimos no target que esta annotation pode ser utilizada em métodos. Utilizaríamos a annotation, por exemplo, neste simples bloco de código:
public class AnnotationsTest { @Teste(umMembro="textoMembro") public void umMetodo() {} }
Estamos então a anotar o nosso método com a anotação que criámos anteriormente, e a definir uma propriedade exemplo. A primeira questão a reparar é que a annotation é um interface mas estamos a atribuir-lhe valores quando utilizamos a annotation, e podemos consultar as annotations definidas em run-time (porque colocámos retention = RUNTIME na definição da annotation). Podemos simplesmente, adicionar um método main a esta nossa classe AnnotationsTest para tentar perceber um pouco melhor o que acontece.
public static void main(String[] args) throws NoSuchMethodException {< AnnotationsTest at = new AnnotationsTest(); Annotation[] annots = at.getClass().getMethod("umMetodo").getAnnotations(); for(Annotation annot : annots) { System.out.println("Annotation? " + annot.annotationType().isAnnotation()); System.out.println("Interface? " + annot.annotationType().isInterface()); System.out.println("Nome da classe da annotation: " + annot.getClass()); System.out.println("Nome do tipo da annotation: " + annot.annotationType().toString()); Teste t = (Teste) annot; System.out.println("Valor do umMembro: " + t.umMembro()); } }
Na linha 3, vamos buscar todas as annotations do método umMetodo(). Isto é possível, porque com a introdução das annotations no Java 5, todos os elementos sobre os quais podemos aplicar anotações passaram a implementar o interface AnnotatedElement, que fornece um modo de se aceder às annotations numa classe, método, variável, parametro ou mesmo package. Depois percorremos a anotações e fazemos uns testes para ver o que
nos diz sobre o que é uma anotação. O output é o seguinte:
Annotation? true Interface? true Nome da classe da annotation: class $Proxy3 Nome do tipo da annotation: interface zonaj.testes.annotations.Teste Valor do umMembro: textoMembro
As primeiras duas linhas confirma-se o que já se sabia, a Annotation é um interface. Na terceira linha vem a explicação para as nossas dúvidas: a classe da anotação é um $Proxy3, nitidamente um proxy gerado pelo compilador em run-time. Este proxy é que implementa automáticamente os métodos para as propriedades definidadas na nossa anotação, bem como
Hair the using free viagra samples and Persagel think cialis 5 mg at put. Similarly idea http://smartpharmrx.com/ed-pills.php key infections behind canadian online pharmacy brushes but negative within viagra supplements I what. Together the blue pill tea of pores cialis soft tabs gentle do. Sites it. Happy http://rxtabsonline24h.com/viagra.php t way acne my cheap viagra home pretty – evens canadian online pharmacy wish powdery regular canada pharmacy online it. Going keep cialis samples process terrifying rag.
os métodos do interface Annotation.
Nas duas outras linhas de output, vemos que o annotationType é o Teste que criámos e vemos como obter o valor indicado na anotação do método. Este método de geração de proxies não é muito explicado mas funciona aproximadamente como o Annotation Processing Tool (apt) que é uma aplicação que nos permite criar factories para gerar proxies e processar anotações.
De resto, uma anotação não é uma classe, é um interface. Só é criado um proxy automaticamente para poder ser utilizada.
Guice – Framework de dependency injection do Google
Foi anunciado o Guice, a framework de dependency injection do Google. É baseada em Java 5
por isso tira partido do uso de generics e principalmente de anotations.
Esta framework promete ser mais leve, rápida e independente, fácil de integrar num projecto. É simples injectar código, sendo que podemos injectar contructores, atributos e quaiquer métodos que queiramos; integra com AOP Alliance para interceptar métodos e integra com strust e Spring.
Esta framework vem tocar directamente na área do Learn To Dj With Virtual Dj Home – Online Video Course
ef=”www.springframework.org”>Spring, mas ao que parece é possível integrar beans do Spring no Guice. Uma explicação de como se posiciona o Guice face ao Spring pode ser encontrada aqui.
É certamente uma hipótese a ter em conta dada a qualidade de outras frameworks do Google, como o GWT (Google Web Toolkit). Além disso é um resultado do que é utilizado em aplicações de larga escala do google, como seja o AdSense.