CLOSURE IMPLEMENTATION ON JAVA – PART II – Using functions with void return

On this post i will show how to make closures of functions with void return type and with varargs parameter.

Unfortunately on java we can’t pass void as parameter of a method, so we can’t use the method Closure.closure to create a closure for this kind of functions. For this purpose, i also created the Closure.closureLast method, and it is really easy to use, first you need to call the FunctionTypeFactory method sync() or async() (depending of the type of closure you want to create), then you call your method (as you may expected this method isn’t really invoked, since you just want to create a reference) and finally call the Closure.closureLast method who creates the reference for this function.

import br.rj.eso.closure.Closure;
import br.rj.eso.closure.FunctionTypeFactory;
import br.rj.eso.closure.exception.ClosureException;



public class Main {

	public static void main(String[] args){
		try{
			TestClosure tc = Closure.convert(TestClosure.class);
			
			System.out.println("regular call");
			tc.saySentence("Hello","world");
			System.out.println("------------------");
			
			//Here we create the closure
			FunctionTypeFactory.sync(); 
			tc.saySentence("you", "can","also");
			Closure<String> closure = Closure.closureLast();
                        //Now we have the closure for this function
			
			System.out.println("closure call");
			closure.call("use","closure","with","varargs");
			System.out.println("------------------");

		}catch(ClosureException e){}
		
	}
	
	public static class TestClosure{
		public void saySentence(String ... words){
			for(int i=0;i<words.length;i++){
				System.out.print(words[i]);
				System.out.print(' ');
			}
			System.out.print('\n');
		}
	}
	

}

Output:
regular call
Hello world 
------------------
closure call
you can also use closure with varargs 
------------------

Closure implementation on java – Part I

I have been working a lot with javascript in recent past, and with this i started to use closure a lot. Backing to Java, i sometimes feel the need of this great tool, and i decided to implement this using only standard Java.

First of all, on my implementation, you can use closure on 2 flavors, sync or async. On this first post i will talk about the sync closure.

You’ll need to download the lib dynamicJ (https://github.com/ericholiveira/dynamicJ). You can download the source and compile by yourself or download the jar (target folder), and you also need to download the lib cglib-nodep-2.2.2.jar (http://grepcode.com/snapshot/repo1.maven.org/maven2/cglib/cglib-nodep/2.2.2)

Example coding showing the lib use.

import br.rj.eso.closure.Closure;
import br.rj.eso.closure.FunctionTypeFactory;
import br.rj.eso.closure.exception.ClosureException;



public class Main {

	public static void main(String[] args){
		try{
			String str = "testClosure";
			TestClosure tc = Closure.convert(TestClosure.class);
			
			System.out.println("regular call");
			tc.sayWord("Hello"); // regular call without closure
			System.out.println("------------------");
			
			Closure closureNoArgs = Closure.closure(FunctionTypeFactory.sync(), tc.sayWord(null));// first example
// of closure, passing only null args, no reference is binded on this closure
			
			System.out.println("closure call with no args");
			closureNoArgs.call("NoArgsCall");//As we have no object binded on the function we need to pass
			System.out.println("------------------");
			
			Closure closureWithArgs = Closure.closure(FunctionTypeFactory.sync(), tc.sayWord(str));// second
// example of closure, passing non-null arg, the reference of this object is binded on this closure, so everytime someone
// execute the method call the first argument will be the "testClosure" String
			
			System.out.println("closure call binding scope");
			closureWithArgs.call();// As we already binded an object to this scope, we dont need to pass
// any arguments. If you try to pass the argument will be ignored as this method accepts only one argument
			System.out.println("------------------");
		}catch(ClosureException e){}
		
	}
	
	public static class TestClosure{
		public String sayWord(String word){
			System.out.println(word);
			return word;
		}
	}
	

}
Output:
regular call
Hello
------------------
closure call with no args
NoArgsCall
------------------
closure call binding scope
testClosure
------------------

First of all, you need to convert the class who contains the methods you want to pass as parameter to a “closurable class” (this class NEEDS to have a default no-args constructor). You can do this with the Closure.convert method passing a class reference or an object of this class as parameter, it will return an “closurable” object, so the methods of this object can be transformed on closures.

The 3 first lines after this, shows to you the method being executed as a regular method. After this i execute the method Closure.closure who creates a reference for a function (and then you can use to pass it as an argument for other methods), the first parameter is a FunctionType, who can be either sync or async, on this example i use sync, the second is the method who you want to create a reference, and then comes the fun, all the non-null parameter used on this function will be binded to it, so in this first example, i only used null, because i don’t want to bind any object, and for this reason (you can see that this lib is smart enough to now that, in this time, you don’t want to execute the method, you just want to create a closure, so the method isn’t executed), when i execute the “call” i need to pass a parameter of type String, so the method executes without any problem (note, if you don’t pass any arguments, the lib will fill it with null args and call the method).

At last comes the most important use of the lib, it show that is possible to bind the scope of a variable in a function, to do this, you need to execute the closure method with a FunctionType e the method you want to make a reference putting non-null args as the parameters of this object (like curry/partial function on javascript), and then, anytime you execute this closure it will be executed with this parameters.

It is thread-safe and also works with varargs or anonymous classes and if you try to pass more arguments then this method accepts, it will just ignore and execute the method.
As the lib do a lot of different (and complex) things i’m gonna make a series of posts explaining how to make your java programs look more “dynamic”.

Jboss como serviço do Windows

Ontem precisei configurar o Jboss como um serviço do Windows no local onde trabalho, para isto segui este passo-a-passo aqui

Vou colá-lo aqui embaixo, porém peço para que acessem o blog que indiquei acima, pois foi ele quem teve o trabalho de criar este passo-a-passo e merece os créditos por ele, vou colar para que seja lido SOMENTE se o original estiver fora do ar.

Ontem precisei configurar um JBoss para ser inicializado com um serviço do Windows e para isso usei o “JBoss Web Native Connectors“.

Os procedimentos que vou mostrar estão orientados ao JBoss 4.2.3, porque essa versão não vem com o utilitário para instalar o serviço do windows no pacode de download padrão.

Então vamos aos procedimentos:

1. Faça o download do “JBoss Web Native Connectors“ versão 2.0.8 correspondente ao seu sistema operacional (Windows 32 ou 64 bits).
2. Descompacte o arquivo “jboss-native-2.0.8-windows-x64-ssl.zip” (no caso de um Windows 64 bits) e copie apenas os arquivos do diretório “bin” (“README-service.txt“, “jbosssvc.exe“, “jbossweb.x64.exe“, “jbosswebw.x64.exe” e “service.bat“) para “JBOSS_HOME\bin“.
3. Edite o arquivo “service.bat” alterando as linhas 75 e 104, de “call run.bat > run.log 2>&1” para “call run.bat -b 0.0.0.0 -c default > run.log 2>&1“. Explicando a linha de comando:
* -b 0.0.0.0 => é para indicar que o servidor pode ser acessado de qualquer máquina na rede.
* -c default => indica que a configuração de servidor a ser iniciada é a “default” (as configurações de servidor do JBoss disponíveis ficam em “JBOSS_HOME\server“).
4. No prompt de comando acesse o diretório “JBOSS_HOME\bin” e execute o comando “service.bat install“.

Com os passos mostrados anteriormente você vai ter um serviço instalado no Windows para o JBoss com o nome “JBAS50SVC“. Para alterar o nome do serviço que será instalado você deve, antes de executar os passos descritos, alterar as linhas 20, 21 e 22 do arquivo “service.bat“ com o nome e descrição mais adequados para o serviço.

Para inicializar as versões do JBoss 5.x.x como serviço do windows você precisa apenas executar os passos 3 e 4 pois essas versões já vem com o utilitário de instalação do serviço.

A fonte que utilizei para esse tutorial foi um post no blog da Adobe com o título “Running LiveCycle on JBoss as a 64-bit Windows Service” portanto, se você quiser consultar minha fonte acesse este link.

No caso do Windows 2008, Windows 7 e Windows Vista lembre-se de executar o prompt de comando como administrador (botão direito “Executar como administrador”) pois se você esquecer desse detalhe o serviço não vai ser instalado corretamente, portanto, muita atenção com esse detalhe.

API Java Reflection – Parte 2

Continuando os posts sobre a linguagem Java (em breve passaremos para frameworks), vamos falar mais um pouco sobre a API Reflection.

Através de uma classe podemos retornar os seus construtores também, para exemplificar ainda utilizando a classe Cachorro adicionamos um campo do tipo String chamado nome e um construtor que recebe uma String, fica assim:

public class Cachorro {
	public String nome;
	public Cachorro(String nome){
		this.nome=nome;
	}
	public String latir(){
		return "Au Au Au";
	}
}

Para executar o construtor que recebe como parâmetro um nome criamos o seguinte código na classe Main (para facilitar a leitura não vou colocar os blocos try/catch):

Class<Cachorro> classeCachorro = Cachorro.class;
Constructor<Cachorro> construtorString = classeCachorro.getConstructor(String.class);
Cachorro toto = construtorString.newInstance("Totó");

Pronto, assim criamos um novo cachorro cujo nome é Totó utilizando Reflection.
Podemos acessar o atributo nome da seguinte forma:

Field campoNome = classeCachorro.getDeclaredField("nome");//Pegando a referência para o campo nome
System.out.println(campoNome.get(toto));// lendo o campo nome do objeto toto e imprimindo na tela

Post simples e rápido… até o próximo.

API Java Reflection – Parte 1

Reflection é uma API do Java que permite um programa examinar a si mesmo, obtendo informações sobre classes, atributos, métodos e afins.Nesta primeira parte vamos aprender a ler algumas informações básicas de uma classe, criar um objeto e invocar um método.

Temos a classe:

package br.eso.tutorial;

public class Cachorro {
	public String latir(){
		return "Au Au Au";
	}
}

e uma classe Main, nesta classe Main, dentro do método main executamos o código:

Class<Cachorro> classeCachorro = Cachorro.class;

Temos agora uma referência para a classe Cachorro (note que é diferente de um objeto da classe Cachorro), a partir daí podemos receber informações como nome da classe, construtores, métodos e atributos. Um exemplo de uso seria:

//Recuperando o nome da classe
System.out.println("Nome da Classe: " + classeCachorro.getSimpleName()); // saída Nome da Classe: Cachorro
Recuperando o nome da classe com a estrutura de pacotes
System.out.println("Nome da Classe com a estrutura de pacotes: "+classeCachorro.getName()); //saída Nome da Classe com a estrutura de pacotes: br.eso.tutorial.Cachorro
// Recuperando uma referência para a classe Pai da classe Cachorro e a partir daí o nome dessa classe
System.out.println("Nome da Classe pai: " +classeCachorro.getSuperclass().getName()); // saída Nome da Classe pai: java.lang.Object

Agora como próximo passo vamos criar uma instância dessa classe (ou seja, um objeto cachorro) e invocar um método.

try {
                        // Criando um novo Cachorro utilizando reflection o trecho classeCachorro.newInstance(); é equivalente a new Cachorro();
			Cachorro cachorro = classeCachorro.newInstance();
			System.out.println("Chamada ao método sem reflection");
                       // Chamando o método sem utilizar reflection
			System.out.println(cachorro.latir()); // saída Au Au Au
			System.out.println("Chamada ao método com reflection");
			try {
// Recuperando uma referência para o método chamado latir da classe Cachorro, note que este método utiliza varargs,
//    como o método latir não recebe nenhum parâmetro, ele é o único parâmetro do método getMethod, caso ele recebesse
//    por exemplo uma String, a chamada mudaria para  classeCachorro.getMethod("latir", String.class); , no caso de receber
//    por exemplo uma String e um Integer seria classeCachorro.getMethod("latir", String.class, Integer.class);
                                
				java.lang.reflect.Method metodoLatir = classeCachorro.getMethod("latir");
				try {
// Invocando o método latir, este método utiliza varargs também o primeiro parâmetro é o objeto sobre o qual 
//    invocaremos este método, os demais são os parâmetros que o método recebe (como é varargs, podem ser 
//    suprimidos), voltando ao exemplo em que recebe uma String e um Integer, uma forma de chamar este método seria 
//    metodoLatir.invoke(cachorro, "exemplo", 1);
                                        
					System.out.println(metodoLatir.invoke(cachorro)); // saída Au Au Au
				} catch (IllegalArgumentException e) {
					// Lançada quando se tenta executar um método com parâmetros ilegais
				} catch (InvocationTargetException e) {
					// Encapsula uma exceção levantada pelo método invocado
				}
			} catch (SecurityException e) {
				//Lançada caso haja violação de segurança
			} catch (NoSuchMethodException e) {
				// Lançada quando o método não existe
			}
		} catch (InstantiationException e) {
//Exceção lançada quando se tenta instanciar um objeto de uma classe utilizando newInstance, porém não é permitido, é
//    lançada por exemplo se for uma classe abstrata ou interface
		} catch (IllegalAccessException e) {
			// Lançado quando não é possível acessar um determinado construtor, atributo ou método
		}

Nos próximos posts aprenderemos mais alguns truques que podemos fazer com esta API.

Abraços,
Erich Oliveira

Código Completo da classe Main:

package br.eso.tutorial;

import java.lang.reflect.InvocationTargetException;



public class Main {

	public static void main(String[] args) {
		
		Class<Cachorro> classeCachorro = Cachorro.class;
		System.out.println("Nome da Classe: " + classeCachorro.getSimpleName());
		System.out.println("Nome da Classe com a estrutura de pacotes: "+classeCachorro.getName());
		System.out.println("Nome da Classe pai: " +classeCachorro.getSuperclass().getName());
		try {
			Cachorro cachorro = classeCachorro.newInstance();
			System.out.println("Chamada ao método sem reflection");
			System.out.println(cachorro.latir());
			System.out.println("Chamada ao método com reflection");
			try {
				java.lang.reflect.Method metodoLatir = classeCachorro.getMethod("latir");
				try {
					System.out.println(metodoLatir.invoke(cachorro));
				} catch (IllegalArgumentException e) {
				} catch (InvocationTargetException e) {
				}
			} catch (SecurityException e) {
			} catch (NoSuchMethodException e) {
			}
		} catch (InstantiationException e) {
		} catch (IllegalAccessException e) {
		}
		

	}

}

Qual a melhor implementação de Collection e Mapas para o meu programa?

Antes de mais nada, o meu lado ator está me demandando muito tempo essa semana, por isso peço desculpas pela falta de posts, e acho que esse mês de maio será bastante corrido, mas vou fazer o possível para manter os posts aqui.

Agora neste post, por sugestão do meu amigo petroleiro Jonas, vou falar um pouco sobre os contâineres das bibliotecas padrão do Java.

Nesta página você pode encontrar um link para a imagem abaixo:

Fluxograma Collection

Como podemos ver, é um fluxograma que deve ser utilizado como base para saber qual contâiner utilizar para atender às necessidades do seu programa.

Temos nessa imagem um ramo com as implementações da interface Set (HashSet, LinkedHashSet e TreeSet), devem ser utilizados contâineres filhos de Set quando NÃO queremos ter 2 (ou mais) elementos iguais (isto é verificado através do método equals), além de permitir que o elemento null seja inserido no máximo uma vez .As 3 implementações desta interface não são sincronizadas, ou seja, se duas ou mais threads utlizam este container e pelo menos uma altera o seu conteúdo a sincronização deve ser feita manualmente, a diferença entre eles é:

HashSet: não mantém qualquer tipo de ordem e conseguimos executar os métodos add, remove e contains em tempo constante (considerando que os elementos estejam dispersos na tabela). Iterar sobre um HashSet é custoso e depende da capacidade da tabela no momento

LinkedHashSet: os elementos ficam ordenados de acordo com a ordem em que foram inseridos, é importante ressaltar que caso um elemento esteja no LinkedHashSet e um novo objeto igual a este (método equals) seja inserido ele mantém a ordem original, ou seja, não irá para o primeiro lugar. Assim como no HashSet iterar sobre todos os elementos é custoso e os métodos add, remove e contains são executados em tempo constante (considerando que os elementos estejam dispersos na tabela).

TreeSet: os elementos são ordenados de acordo com o método compareTo (interface Comparable). Os métodos add, remove e contains são executados em tempo log(n)

Quando queremos contâineres sincronizados podemos utilizar Stack e Vector:

Vector: Funciona de maneira análoga a um vetor, ou seja os elementos podem ser acessados através de índice (através do método get)

Stack: Funciona como uma pilha de elementos, o último elemento a ser inserido é o primeiro a ser removido (através dos métodos push e pop). Essa classe é filha de Vector

Para acesso rápido aos elementos (add, remove, contains e iteração) utilizamos LinkedList, que nada mais é do que uma implementação de uma lista encadeada

ArrayList é muito semelhante ao Vector com a diferença de que não é sincronizado, adicionar n elementos é feito em tempo O(n)

Para Mapas temos o seguinte:

HashMap: Tempo constante para as operações get e put (assumindo que os elementos estejam dispersos na tabela), utiliza o método equals para encontrar a chave

IdentityHashMap: A diferença para o HashMap é que utiliza o operador == ao invés do método equals. De maneira geral fuja dele.

LinkedHashMap: HashMap que mantém as chaves na ordem em que foram inseridas.

TreeMap: Implementação de uma árvore rubro-negra. Os métodos get, put e remove são feitos em tempo log(n) e as chaves ficam ordenadas pelo método compareTo(interface Comparable)

HashTable: Semelhante ao HashMap porém é sincronizada e não aceita chaves null;

——– EXTRA ——–

Cansado da famigerada ConcurrentModificationException e performance não é um problema????

CopyOnWriteArrayList que funciona como um ArrayList porém o custo de inserção é muito alto, ou CopyOnWriteArraySet que é semelhante ao CopyOnWriteArrayList porém sem permitir elementos iguais

Java Básico: Redefinição de métodos para um único objeto

Em java temos a liberdade de redefinir um método para um único objeto. Pode parecer estranho querer fazer isso, mas em breve postarei sobre padrões de projeto, e entre estes padrões existe o padrão Command, onde esse tipo abordagem é particularmente útil. Mas vamos deixar esse assunto mais pra frente e vejamos como funciona isso.

Eu criei uma classe cachorro, com um único método public String latir(). Ela foi implementada da seguinte forma:

public class Cachorro {
	public String latir(){
		return "Au Au Au";
	}
}

Assim temos a nossa classe cachorro, agora vamos criar um Main onde temos 2 objetos, um cachorro normal e outro cachorro com o método latir alterado e vejamos o comportamento desses objetos:

public class Main {
	public static void main(String[] args) {
		Cachorro fido = new Cachorro();
		System.out.println(fido.latir());
		Cachorro thor = new Cachorro(){
			public String latir(){
				return "Eu sou um cachorro que fala";
			}
		};
		System.out.println(thor.latir());
	}
}

A saída do programa é :

Au Au Au
Eu sou um cachorro que fala

Essa é a saída esperada para o segundo objeto cachorro (thor) alteramos o método latir, a sintaxe para fazer isso é muito simples, instanciamos o objeto normalmente com o operador new e entre chaves reimplementamos todos os métodos que queremos.

Bom é isso… post rápido de um assunto bem simples mais que muitos não conhecem, espero que tenham gostado.