Neste tutorial veremos como construir o seu primeiro Agente JADE. De uma forma geral, um agente JADE é uma thread convencional na linguagem Java. Neste artigo ensinaremos três formas de implementação e execução: uma por linha de comando do Windows, outra pelo IDE Netbeans e a última pelo Visual Studio 2013.
Implementação e Execução pela linha de comando
Na Listagem 1 é possível verificar um código simples de implementação de um Agente JADE. Neste exemplo prático exibimos na tela a épica frase “Hello World”. É necessário observar que todo agente criado deve ser uma extensão da classe Agent do framework JADE.
Na primeira linha é feita uma importação da classe Agent para o código Java. Na linha 3 declare o nome da classe e utilize a claúsula extends para que a mesma possa estender a implementação da classe Agent. Na linha 5 é feita a declaração do método setup, que é o primeiro e o principal método de execução do agente, pois todos os demais métodos para serem executados devem ser chamados dentro do método setup. Na linha 7 é realizada a chamada de uma função que imprime na janela do console a frase “Hello World. I’m an agent!”.
Listagem 1. Exemplo prático de implementação de um agente JADE em Java.
1 import jade.core.Agent;
2
3 public class HelloWorldAgent extends Agent {
4
5 protected void setup() {
6
7 System.out.println("Hello World. I’m an agent!");
8
9 }
10 }O código exibido na listagem acima pode ser criado em qualquer editor de programação, como o Notepad++. Após criar o seu código, salve-o em um arquivo com o nome da classe do exemplo acima e com a extensão .java: no exemplo acima o nome do arquivo será “HelloWorldAgent.java”.
Após criar o seu arquivo de código Java, abra o prompt de comando do Windows e procure o diretório onde você armazenou o seu arquivo de código Java e compile o código através do comando a seguir:
“javac HelloWorldAgent.java”Não havendo nenhum erro, automaticamente será criado um arquivo chamado “HelloWorldAgent.class” no mesmo diretório onde está o arquivo .java, que será utilizado para executar seu agente. Essa execução ocorrerá com o comando a seguir:
java jade.Boot –agents <nomedoagente>:<nomedaclasse>Onde <nomedoagente> é o nome que você irá dar ao seu agente e <nomedaclasse> é o nome da classe do seu agente, que em nosso exemplo ficou como “HelloWorldAgent”. É obrigatório colocar o nome do agente, pois este será o seu identificador único na plataforma JADE, neste exemplo vamos dar o nome do nosso agente de “Andre”. Portanto, para executar o agente da Listagem 1 execute o comando a seguir:
java jade.Boot –agents Andre:HelloWorldAgentApós executar este comando, automaticamente, a plataforma JADE será iniciada pela execução do Container Principal (Main Container), o agente será registrado e logo em seguida será colocado em execução. Note que não é necessário se preocupar com a plataforma, pois isto acontecerá de forma automática, inclusive o registro do agente na mesma. A Figura 1 ilustra como deverá aparecer a execução do agente exemplo na linha de comando. Como pode ser observado, o Main Container é inicializado junto com os seus serviços como serviços de gerenciamento de agentes, recursos, mensagens e etc..
Em algum momento o agente é inicializado, como pode ser observado pela seta alaranjada, indicando a função que imprime na tela a frase “Hello World, I’m na Agent”.
Figura 1. Ilustração da execução do agente da Listagem 1.
Outra forma de executar o agente é através da Interface Gráfica do JADE. Para isto é necessário executar o seguinte comando no Prompt:
java jade.Boot –gui <nomedoagente>:<nomedaclasse>Após executar este comando, o Main Container será inicializado, conforme já observado na Figura 1. A diferença é que será exibida uma janela da interface gráfica do JADE, onde pode ser observado o agente de nome “Andre” sendo executado na plataforma, conforme destacada na Figura 2. Além disso, os agentes ams, df e rma são utilizados para gerenciar, registrar e mover agentes e/ou mensagens na plataforma, respectivamente.
Figura 2. Visualização do agente Andre pela Interface Gráfica do JADE.
Também existe a possibilidade de executar vários agentes simultaneamente. Basta colocar “;” entre cada declaração de agente, como pode ser observado na Listagem 2. Além disso, você pode utilizar a mesma classe para executar vários agentes quanto quiser.
Listagem 2. Como executar vários agentes simultaneamente
java jade.Boot –agents <nomedoagente1>:<nomedaclasse>;<nomedoagente2>:<nomedaclasse>;...;<nomedoagenteN>:<nomedaclasse>Na Listagem 3 é ilustrado um exemplo de como executar três agentes utilizando a mesma classe. Vale salientar que, apesar de fazer uso do mesmo arquivo; o acontece em tempo de execução é a execução de três cópias do arquivo. Na Figura 3 é possível observar, a execução dos três agentes simultaneamente, conforme pode ser observado pelas setas alaranjadas.
Listagem 3. Como executar vários agentes simultaneamente.
java jade.Boot –agents Andre:HelloWorldAgent;Carlos:HelloWorldAgent;Juca:HelloWorldAgent
Figura 3. Ilustração da execução de três agentes da mesma classe.
Também existe a possibilidade de execução de vários agentes simultaneamente e de serem visualizados na interface gráfica do JADE. Para isto basta executar o comando descrito na Listagem 4. Na Figura 4 é possível visualizar os três agentes, em destaque, pela interface gráfica.
Listagem 4. Comando para execução de vários agentes e visualização na interface gráfica.
java jade.Boot –gui <nomedoagente1>:<nomedaclasse>;<nomedoagente2>:<nomedaclasse>;...;<nomedoagenteN>:<nomedaclasse>
Figura 4. Ilustração dos três agentes visualizados pela interface gráfica.
Implementação e Execução pela IDE Netbeans
A seguir será descrito como implementar agentes na IDE Netbeans. Esta implementação pode ser realizada de duas formas: sem classe principal e com classe principal. Em ambas implementações é necessário importar o JADE para dentro do seu projeto.
Implementação sem Classe Principal
Crie um projeto de aplicação Java convencional (Figura 5), clicando no ícone quadrado laranja no canto superior esquerdo, e no procedimento de criação desmarque a opção de criar classe principal e dê qualquer nome ao seu projeto (Figura 6).
Figura 5. Ilustração de como criar um projeto convencional Java no Netbeans.
Figura 6. Ilustração para desmarcar a opção de criar classe principal.
Após criar o seu projeto clique com o direito do mouse ou touchpad e selecione a opção novo e logo em seguida clique na opção “Classe Java”; em seguida nomeie a classe do mesmo nome do exemplo contido na Listagem 1 para facilitar a compreensão. Após criar a classe, utilize o mesmo código contido na Listagem 1. Você irá perceber que o compilador vai alertar que existe um erro na linha “import jade.core.Agent;”; isto porque o compilador não reconhece esta biblioteca de classes já que esta classe não é uma classe nativa do Java. Para resolver este problema é necessário importar o framework JADE para o seu projeto. No post intitulado “NetBeans IDE: Instalando e configurando o JADE”, eu ensino a como criar a biblioteca do Framework JADE para ser utilizado em qualquer projeto no ambiente Netbeans. Para importar a biblioteca do Framework JADE no seu projeto clique com o botão direito do mouse ou touchpad na pasta bibliotecas e selecione a opção “Adicionar biblioteca” e sem seguida escolha a biblioteca que representa o Framework JADE (Figura 7); outra alternativa é escolher a opção “Adicionar JAR/Pasta” e ir até o diretório onde você instalou o JADE em seu computador e selecionar o arquivo jade.jar que geralmente está contido na pasta “lib” (Figura 8); como mostrado na Figura 8, não esqueça de marcar a opção “Caminho Absoluto” como mostrado pela seja alaranjada. Automaticamente o compilador vai reconhecer esta biblioteca e removerá o erro. Vale salientar que é necessário a importação do JADE para o seu projeto, quer seja por meio de biblioteca ou o seu próprio executável JAR porque é por meio deste que é possível configurar o JADE como classe principal do projeto.
Figura 7. Importando biblioteca do JADE para projeto Netbeans.
Figura 8. Importando executável JAR do Framework JADE.
O próximo passo é configurar o JADE como classe principal do projeto, mais especificamente a classe jade.Boot que é a classe responsável por iniciar a plataforma JADE. Para isto, clique com o botão direito do mouse no seu projeto e escolha a opção “Propriedades”. Na próxima janela escolha a opção “Executar”. Crie uma nova configuração clicando no botão “Novo” ou se preferir pode usar a padrão; as configurações são maneiras de se executar um projeto configurando informações referente a classe principal, seus argumentos e demais informações que não entrarei em detalhes no post. Na opção Classe Principal digite “jade.Boot” e na opção Argumentos podem ser utilizadas os mesmos argumentos presentes nas listagens anteriores para inicialização de um ou vários agentes e de um ou vários agentes com visualização pela interface gráfica do JADE (Figura 9).
Figura 9. Configurando o JADE como classe principal do projeto.
A Figura 10 ilustra a execução do projeto de agentes com a execução de dois agentes simultaneamente. Conforme pode ser observado na janela de saída do Netbeans, a impressão dos das frases “Hello World! I’m na Agent!” pelos agentes. Na Figura 11 é ilustrado a execução de dois agentes simultaneamente e a visualização de ambos na interface gráfica do JADE.
Figura 10. Ilustração da execução de dois agentes simultaneamente.
Figura 11. Ilustração da execução de agentes com visualização pela interface gráfica do JADE.
Implementação com Classe Principal
A implementação com classe principal também necessita que o Framework JADE também tenha sido importado para o projeto. Tendo em vista que já foi citado anteriormente como importar o JADE para projetos Java no Netbeans agora seguir para as próximas etapas. A próxima etapa será a implementação das classes; crie uma classe agente igual ao da Listagem 1 e após isto coloque as seguintes linhas de código descritas na Listagem 5. Como pode ser observado, a linha um permite instanciar um objeto do tipo “Runtime” que possa controlar o Framework JADE em tempo de execução. A segunda linha cria um objeto “Profile” que serve de perfil de identificação para container de agentes, onde a relação é de um perfil por container. Na linha três é instanciado o Container Principal (Main Container) com o perfil que foi criado para ser controlado por um objeto da classe “ContainerController”. Na linha quatro é criado um agente que será controlado por um objeto “AgentControler”; note que a criação do agente acontece pelo uso do objeto “ContainerController” previamente criado; note também que são passadas três variáveis como parâmetros de entrada, uma variável do tipo “String” que corresponde ao nome agente, uma variável do tipo “String” que corresponde ao caminho no seu projeto Java onde está localizada a classe do agente e uma variável de “array” de objetos que representam argumentos que são passados para a inicialização do agente.
Listagem 5. Objetos necessários para execução de um agente JADE.
1 Runtime rt = Runtime.instance();
2 Profile p = new ProfileImpl();
3 ContainerController cc = rt.createMainContainer(p);
4 AgentController ac = cc.createNewAgent(“Agente”,”pacote.Classe”, args);
5 ac.start();Automaticamente o compilador do Netbeans irá notificar sobre erros, então você deverá importar as seguintes classes JADE para a sua classe (Listagem 6). A classe “Runtine” é utilizada para permitir execução do Framework JADE em tempo de execução. A classe “Profile” permite a criação de perfis para container. A classe “ProfileImpl” permite a criação de perfis para o Main Container; se a sua aplicação de agentes estiver distribuída na rede existe a possibilidade de distribuir na rede container secundários e de container principais. A classe “AgentController” permite controlar agentes, porém deve ser um utilizado um objeto desta classe para cada agente instanciado. A classe “ContainerController” permite controlar containers de agentes, porém deve ser um utilizado um objeto desta classe para cada container instanciado.
Listagem 6. Classes necessárias para execução de agentes JADE.
import jade.core.Runtime;
import jade.core.Profile;
import jade.core.ProfileImpl;
import jade.wrapper.AgentController;
import jade.wrapper.ContainerController;A Figura 12 ilustra a execução de um agente JADE em um projeto Java com classe principal. Note que as instruções de código descritas na Listagem 6 estão envolvidas dentro um instrução “try-catch” e que deve ser obrigatória para evitar comportamentos inesperados na execução de códigos. Instruções “try-catch” são utilizadas para tratar exceções que ocorrem quando o código foge de seu escopo de comportamento padrão. Como pode ser observado na Figura 12, a linha 17 ilustra a criação de um agente com o nome “Andre” usando a classe “HelloWorldAgent” contida no pacote “Main”. Neste tipo de implementação utilizada não é possível fazer uso do recurso de interface gráfica, mesmo que tente invoca-la por linha de comando não será possível uma vez que o container principal já foi inicializado.
Figura 12. Ilustração de execução de agente em projeto Java com classe principal.
Existe uma classe na API do JADE que é responsável pela interface gráfica que é criada quando se executa o Framework JADE por linha de comando. Esta classe é chamada de “rma”, responsável pelo gerenciamento de agentes em tempo de execução. Para abri-la em sua aplicação Java só é necessário passar esta classe como parâmetro na criação de um agente. A Listagem 7 a seguir ilustra um exemplo de código onde, no ato da criação passar como argumento qualquer nome de agente e o caminho de onde está, a classe que é “jade.tools.rma.rma”, tudo isto porque a classe “rma” também é um agente.
Listagem 7. Interface gráfica
public static void main (String[] args) {
try{
Runtime rt = Runtime.instance();
Profile p = new ProfileImpl();
ContainerController cc = rt.createMainContainer(p);
AgentController ac = cc.createNewAgent(“Andre”,”Main.HelloWorldAgent”, args);
AgentController rma = cc.createNewAgent(“rma”, “jade.tools.rma.rma”, args);
ac.start(0;
rma.start();
} catch (Exception e){
System.out.println(“Erro: “ + e.getMessage());
}Assim como acontece por linha de comando, fechar a janela da interface gráfica não finaliza a execução da plataforma JADE. Porém, executar a plataforma por uma aplicação Java permite que o usuário possa criar uma classe que estenda da classe “rma” e altere o evento de fechar a interface para que, após fechar a janela da interface, a plataforma também seja finalizada. Contudo, a implementação desta rotina requer conhecimento em tratamento de eventos que ocorrem em interfaces gráfica do Java e que não será abordado neste post.
Implementação e Execução pela IDE Visual Studio
A plataforma JADE é implementada em Java e suas bibliotecas não podem ser importadas diretamente para aplicações .NET devido incompatibilidade. Contudo, a plataforma JADE dispõe de uma versão “dll” para usar o JADE em aplicações .NET chamada de “JadeLeap”, mas que não dispõe de todos os recursos por ser uma versão portátil destinada a aplicações embarcadas. Além disso, existe disponível no mercado algumas propostas para integrar Java no .NET, entre elas estão as iniciativas JNBridge, jni4net e IKVM.NET, que provavelmente podem ser testadas para viabilidade da integração. Neste post será tratado somente o uso de JadeLeap para implementar e executar agentes no .NET.
Ele possui como dependência o pacote de distribuição do Microsoft Visual J# versão 2.0. Contudo, este pacote já vem instalado dentro do Framework .NET 2.0.
Neste exemplo utilizaremos a IDE Visual Studio 2013, utilizando a linguagem VB.NET. Crie um projeto Visual Basic do tipo “Console Application” e selecione o Framework .NET na versão 2.0, conforme ilustrado na Figura 13 e sinalizado pela seta alaranjada - o nome do projeto é “AgenteJADE”.
Figura 13. Ilustração da criação do projeto VB.
O projeto aparecerá do lado direito da IDE na guia “Solution Explorer” e, ao clicar com o botão direito sobre ele, escolha a opção “Add” -> “Reference...” para que uma nova janela seja aberta. Nela clique no botão com o nome “Browse...” e procure nos diretórios do JadeLeap pelos arquivos “JadeLeap.dll” e “Commons-Codec.dll” e no diretório do Framework .NET 2.0 procure pelo arquivo “vjslib.dll” e depois clique no botão “OK”. Automaticamente estas dll’s serão importadas para a sua aplicação, como mostra a Figura 14.
Figura 14. Importando as dll’s necessárias para o projeto.
A próxima etapa é criar uma classe chamada agente. Clique com o botão direito no seu projeto e escolha a opção “Add”, em seguida “Class...” e dê o nome de “HelloWorldAgent.vb”. A Listagem 8 tem o código que descreve a importação do pacote núcleo do JADE com todas as suas classes. As linhas 3 e 4 mostra que a classe “HelloWorldAgent” está herdando da classe “Agent”. A linha 6 descreve a reescrita do método “setup” e a linha 8 mostra uma função que imprime na tela o texto passado como parâmetro.
Listagem 8. Código da classe do agente
1 Imports jade.core
2
3 Public Class HelloWorldAgent
4 Inherits Agent
5
6 Public Overrides Sub setup()
7
8 Console.WhriteLine(“hello World1 I’m an Agent”)
9
10 End Sub
11
12 End ClassApós a escrita do código do agente, agora se escreve o código da classe principal. A Listagem 9 descreve o código da classe principal: as linhas 1 e 2 descrevem os pacotes importados com as classes necessárias, onde também estão circundadas pela cláusula try-catch. Das linhas 10 a 14 ocorre a criação de um vetor de objetos passado como argumento na criação do agente, criação do objeto responsável pela plataforma JADE em tempo de execução, criação do objeto do perfil do container, do container principal e do agente, respectivamente. Lembre-se de colocar o caminho da classe do agente por extenso, inclusive se estiver em vários diretórios.
Listagem 9. Código da classe principal
1 Imports jade.core
2 Imports jade.wrapper
3
4 Module Module1
5
6 Sub Main()
7
8 Try
9
10 Dim args() As Object
11 Dim rt As Runtime = Runtime.instance
12 Dim p As Profile = New ProfileImpl
13 Dim cc As ContainerController = rt.createMainContainer(p)
14 Dim ac As AgentController = cc.createNewAgent(“Andre”, “AgenteJADE.HelloWorldAgent”, args)
15
16 ac.start()
17 Catch e As exception
18 Console.WriteLine(e.Message + “ “ + e.ToString)
19 Console.ReadKey()
20 End Try
21
22 End Sub
23
24 End ModuleTudo pronto para execução da aplicação. Lembre-se de selecionar que tipo de plataforma a aplicação será executada que é em uma máquina de processador de 32 bits, também conhecido como x86. Para isto, clique na aba que fica ao lado da aba “Debug” no canto superior da tela e seleciona a opção “Configuration Manager...” e crie um perfil com processador x86. Aplicações utilizando JadeLeap só funcionam em processadores x86 para compatibilidade com as limitações da versão portátil do JADE. Feito isto, clique no botão “Start”, que fica ao lado da aba “Debug”. Provavelmente você obterá um resultado semelhante ao que é mostrado na Figura 15.
Figura 15. Ilustração da execução da aplicação.
Infelizmente, devido as limitações do JadeLeap, não existe a classe “rma” para executar a interface gráfica do JADE. Contudo, existe a possibilidade de execução da interface gráfica, pela linha de comando, paralelamente com a aplicação do Visual Studio. Para isto, é necessário modificar a aplicação para que, ao invés de criar o Main Container, crie um container de agentes comum. Substituindo a instrução “rt.createMainContainer(p)” pela instrução “rt.createAgentContainer(p)” na linha 13 conforme ilustrado na Figura 16. Feito isto, execute a interface gráfica pela linha de comando usando a instrução “java jade.Boot -gui” e logo em seguida, executando a aplicação do Visual Studio.
Figura 16. Execução da interface gráfica paralelo a aplicação do Visual Studio.
Como foi observado neste post, é possível descrever diversas maneiras de implementação e execução de agentes JADE, tanto por linha de comando quanto em projetos de IDE. As diversas formas mostradas aqui não são exaustivas e existem diversas outras possibilidades que podem ser utilizadas, como utilizando vários prompts de comando simultaneamente, prompt(s) de comando com IDE’s e a integração de prompt(s) de comando com diversas aplicações usando JADE no Netbeans e Visual Studio.
