software‎ > ‎módulos‎ > ‎engine‎ > ‎perguntas frequentes‎ > ‎

Como fazer para executar código Java no iEngine?

postado em 11 de mai de 2010 08:22 por Usuário desconhecido   [ atualizado em 1 de jul de 2016 12:52 por Marcelo Rocha ]

A partir da versão 9.1.0.1 do iEngine, já é possível executar código Java. A integração a feita através do Enginelet. Enginelet é uma API que é distribuída junto como iEngine que permite a Integração da plataforma iEngine com a plataforma Java. Segue abaixo a lista de requisitos necessários para iniciar o desenvolvimento de um código Java conectável ao iEngine:

Requisitos

Java SE Development Kit (JDK) 6 (http://java.sun.com/javase/downloads/index.jsp)
Eclipse Web Tools Platform - WTP (http://download.eclipse.org/webtools/downloads/)

Passo-a-Passo

  1. Primeiramente baixe as bibliotecas Java (*.jar) necessárias. As bibliotecas java estão disponíveis na iVFS e a forma mais fácil de baixar é executando um método do objeto JavaImporter, veja como:

    Abra o iDBCSql e execute o seguinte código:

    var javaimporter = new JavaImporter()
    javaimporter.importJavaBean( "java.util.Date" )

  2. Ao executar o código acima o iEngine procurar por todos os arquivos *.jar ou *.zip dentro das classes root/products/<Árvore do Time>/library/javalibs e baixar na pasta <Pasta do iEngine.exe>/javalibs.

    O arquivo do enginelet deve se chamar enginelet<Versão>.jar.

    Outra forma de baixar as javalibs é usando o processo Ir Para>Desenvolvimento>Virtual File System>Exportar arquivos.

  3. Abra o Eclipse e crie um novo projeto java seguindo os passos:
    • File/New/Project...
    • Selecione a opção Java Project e clique em Next. Irá aparecer a seguinte janela:


    • Informe um nome para o projeto e informe uma JRE cuja a versão seja maior ou igual a 1.6.0_04 e clique em next. Aparecerá a seguinte tela:


    • Neste tela clique na Aba chamada "Libraries" e em seguinda no botão Add External JARs... e selecione o arquivo enginelet<Versão>.jar que foi baixado da iVFS e clique no botão Finish. Pronto! Projeto criado!

  4. Agora crie um Enginelet chamado EngineletDeTestes. Vá em File/New/Class e preencha a tela da seguinte maneira:



    Aqui cabe uma consideração importante sobre campo Package: Você deverá criar um pacote único, muito cuidado com as colisões de nomes de pacotes. Não pode haver uma classe com nomes iguais em pacotes iguais, mesmo que em arquivos JARs diferentes.


  5. Clique no botão Finish para criar a classe. O Eclipse irá gera uma classe "esqueleto". Eis o código gerado:

    1.     //Aqui fique atento para o nome do pacote que você tá criado, se um desenvolvedor
          //já fez um enginelet de teste no mesmo pacote que você o seu teste não irá
          //funcionar. Lembre-se que não pode haver colisões de nomes de classes, mesmo que
          //elas estejam em JARs diferentes.

        package br.com.unum.testes.enginelet;

        import br.com.inteq.engine.enginelet.Enginelet; 

        public class EngineletDeTestes extends Enginelet { 

            @Override
            public String handleCommand(String arg0, String[] arg1) { 
                    return null; 
            } 
        }

    2. Altere a assinatura do método handleCommand para:
      handleCommand(String commandName, String[] commandArgs)

    3. Implemente o método handleCommand da seguinte forma: 

    4. public String handleCommand(String commandName, String[] commandArgs) {
          commandName = commandName.toUpperCase();
          if( commandName.equals("DIGAOLA") ) {
              //Obtém o valor do primeiro parâmetro da chamado do método handleCommand
              //chamado no ambiente JavaScript.
              String nome = commandArgs[0];
              //Retorna uma string para o ambiente JavaScript
              return "Olá Sr(a). " + nome;
          }
          else if( commandName.equals("DIGAADEUS") ) {
              //Obtém o valor do primeiro parâmetro da chamado do método handleCommand
              //chamado no JavaScript.
              String nome = commandArgs[0];
              //Retorna uma string para o ambiente JavaScript
              return "Até mais Sr(a). " + nome;
          }
          else {
              return "O comando " + commandName + " não foi reconhecido.";
          }
      }


    5. Falta apenas compilar e empacotar o código compilado em um arquivo *.jar. Recomendamos o uso do ANT (http://ant.apache.org/). O ANT já vem com Eclipse WTP. Segue abaixo um script genérico que pode ser adaptado para este exemplo específico. O arquivo deve ser criado no dirtório do código fonte(src):

    6. <?xml version="1.0" encoding="UTF-8"?>
      <project name="" basedir="." default="compile">
               <!--Área de customizável do script-->
          <!--Infome a versão aqui-->
          <property name="version" value=""/>
          <!--Infome o diretório onde se encontram os fontes-->
          <property name="directory.source" value="."/>
          <!--Informe o diretório onde serão gerados os binários-->
          <property name="directory.binary" value="../bin"/>
          <!--Informe o diretório onde serão gerados os arquivos empacotados para distribuição(*.jar)-->
          <property name="directory.distribuition" value="../dist"/>
          <!--Informe o diretório onde será gerada a documentação javadoc-->
          <property name="directory.documentation" value="../doc"/>
          <!--Infome o diretório onde estão as bibliotecas java-->
          <property name="directory.javalibs" value=""/>
          <!--Informe o título da documentação javadoc-->
          <property name="documentation.title" value=""/>
          <!--Informe o nome completo do arquivo JAR-->
          <property name="jarfile" value="${directory.distribuition}/enginelet-${version}.jar"/>
          <!--Fim da área de customizável do script-->


          <target name="compile">
              <mkdir dir="${directory.binary}"/>
              <javac destdir="${directory.binary}" srcdir="${directory.source}">
                  <classpath>
                      <fileset dir="${directory.javalibs}"/>
                  </classpath>
              </javac>
          </target>
          
          <target name="makeDocumentation">
              <mkdir dir="${directory.documentation}"/>
              <javadoc windowtitle="${documentation.title}" sourcepath="${directory.source}" destdir="${directory.documentation}"></javadoc>
          </target>


          <target name="makeDistribuition" depends="compile">
              <mkdir dir="${directory.distribuition}"/>
              <jar destfile="${jarfile}" basedir="${directory.binary}"></jar>
          </target>
                  
          <target name="clean">
              <delete dir="${directory.binary}"/>
              <delete dir="${directory.distribuition}"/>
          </target>
      </project>


    7. Salve o script ANT com o nome build.xml;

    8. Agora precisamos processar o script para gerar o arquivo JAR. O Eclipse já faz o processamento de scripts ANT. Certifique-se que a View do ANT está visível no Eclipse. Habilite em: (Window / Show View / Ant);

    9. Arraste o arquivo build.xml para a View ANT e clique duas vezes na Task makeDistribuition do script ANT dentro da View ANT.

    10. O arquivo JAR será gerado na pasta <Diretório do Projeto>\dist

    11. Copie o arquivo JAR gerado para a pasta <Pasta do iEngine.exe>/javalibs. Por não constar na iVFS, o arquivo JAR copiado, será apagado pelo processo de sincronização das javalibs com a iVFS. Você pode desabilitar o sincronismos das javalibs simplemente criando o arquivo .ignoresync na pasta <Pasta do iEngine.exe>/javalibs (Use o notepad.exe para criar o arquivo).

    12. Recomendamos o uso do .ignoresync apenas na fase de desenvolvimento, após a fase de desenvolvimento o mesmo deve ser removido e os arquivos JAR necessários devem ser levados para a iVFS.

    13. Abra a IDE e digite e execute o seguinte código no iDBC:

    14. var enginelet = new Enginelet("br.com.unum.testes.enginelet.EngineletDeTestes") enginelet.handleCommand("DigaOla", "Paulo Rogério")


    15. O resultado será:
    16. Olá Sr(a). Paulo Rogério.

    17. Agora iremos levar o Enginelet de testes para a iVFS. Sigua os passos:
      • Crie uma classe chamada javalibs dentro da classe. root/products/<Árvore do Produto>/library;
      • Use o processo de importação para iVFS(para importar as javalibs para a pasta criada)
      • Caso esteja usando o arquivo .ignoresync, remova-o.

    Segue em anexo a documentação da API Enginelet.

    IMPORTANTE: Ao compilar as classes, a VM target deve ser no máximo a versão 1.7 do Java.

    IMPORTANTE: Algumas distribuições da versão 1.6 da JRE possuem bug. Sugerimos realizar a atualização da sua JRE antes de usa o ambiente Java integrado com o uEngine.