[Logo] Mentawai Forum - Mentawai Web Framework
  [Search] Search   [Recent Topics] Recent Topics   [Members]  Member Listing   [Groups] Back to home page 
[Register] Register / 
[Login] Login 

Forum Read-Only! Check the new site and forum here!

FAQ do Mentawai (Não deixe de ler !!!)  XML
Forum Index -> Comentários Gerais
Author Message
saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

1) O que é IoC e pra que serve o IoCFilter do Mentawai ?

Inversão de Controle é a arte de programar sem gerar acoplamentos entre as classes, isto é, uma classe não deve nunca instanciar outra classe dentro dela.

Ex:

Code:
 
 public class Carro {
 
    private final Motor1000 motor;
 
    public Carro() {
 
       this.motor = new Motor1000();
 
    }
 
 }
 


A classe Carro acima está fortemente acoplada a classe Motor1000. Algumas desvantagens desse exemplo são:

Se amanhã eu precisar trocar o motor do meu carro, terei que obrigatoriamente recompilar o código da classe Carro.

Um erro mais gritante é que a classe carro está acoplada a uma classe concreta e não a uma interface, o que é um atente contra as regras de flexibilidade e refatoração.

Para deixarmos a coisa totalmente flexível e desacoplada, poderíamos fazer assim:

Code:
 
 public interface Motor {
 
 // métodos comuns a todo motor aqui...
 
 }
 
 public class Motor1000 implements Motor {
 
    // implementação dos métodos da interface aqui...
 
 }
 
 public class Carro {
 
    private Motor motor;
 
    public Carro() {
 
    }
 
    public void setMotor(Motor motor) {
      
        this.motor = motor;
    }
 
 }
 
 


Note que agora a classe carro está acoplada a uma interface e não mais se preocupa em criar uma implementação de motor. Essa implementação será passada pra ela através do método setMotor() (setter).

Ex:

Code:
 
 Carro gol1000 = new Carro();
 gol1000.setMotor(new Motor1000());
 
 


Entretanto o código acima está novamente criando um acoplamento forte com new Motor1000(), ou seja, está instanciando uma classe concreta diretamente no código. Como escapar desse acoplamento então ? A solução é usar um container de IoC, ou seja, um serviço ou framework externo que se encarrega de criar e passar (injetar) a instância do seu objeto para um outro objeto que precisa dela.

O Mentawai é também um poderoso container de IoC, como veremos a seguir.

O primeiro passo é, ao invés de usar new para criar um objeto, usaremos um componente de IoC que, via reflection, se encarregará de nos fornecer instâncias da classe em questão:

Code:
 
 ioc("motor", Motor1000.class); // definindo o componente de IoC "motor"
 
 filter(new IoCFilter()); // filtro global que transforma o Mentawai num container de IoC
 
 // dentro da sua action vc pode fazer:
 
 Motor motor = (Motor) input.getValue("motor");
 
 


No código acima, tudo que estamos definindo é:

Temos um componente motor que vai gerar instancias a partir da classe Motor1000.class

Esse component (motor) é definido totalmente fora da sua aplicação, em outras palavras, ele é definido nas configurações do seu projeto (ApplicationManager.java).

O IoCFilter é um filtro global que transforma o Mentawai num poderoso container de IoC. Através dele, de forma totalmente automática e transparente, sempre que sua action requisitar o parâmetro "motor" do input, o Mentawai se encarregará de entregar uma instância correspondente ao componente em questão.

O IoCFilter é esperto o suficiente para gerenciar a criação das instâncias de acordo com o escopo do componente, como veremos mais abaixo. O escopo default é REQUEST, ou seja, quando não especificarmos um escopo, o escopo assumido será REQUEST.

Note que além de REQUEST, que é o escopo default, temos também outros dois escopos:

SESSION: A instancia irá persistir ao longo da session do usuário, ou seja, enquanto a sessão for a mesma, sucessivas chamadas ao método input.getValue("motor"); irão retornar a mesma instância.

APPLICATION: A instancia irá persistir durante toda a sua aplicação, ou seja, será a mesma até que sua aplicação seja restartada. (Quem precisa de singleton quando se tem IoC ???)

Note que mesmo para o escopo REQUEST, sucessivas chamadas ao método input.getValue("motor"); irão retornar a mesma instância, desde que estejamos dentro do mesmo request, ou seja, o container de IoC do Mentawai gerencia de forma precisa a criação de instâncias para cada escopo.

Para definirmos um componente de IoC com escopo, fazemos assim:

Code:
 
 ioc("motor", Motor1000.class, SESSION);
 
 // ou
 
 ioc("motor", Motor1000.class, APPLICATION);
 
 


Note também que nada nos impede de utilizar o InjectionFilter para injetar os componentes de IoC diretamente na sua action, ou seja, se sua action possui a propriedade "motor" o InjectionFilter se encarregará de injetá-la sem que vc precise acessar o input da action ou fazer qualquer coisa.

Outra coisa que devemos notar é que o InjectionFilter não impõe que a sua action defina um método setter (setMotor()) para receber o objeto que está sendo injetado. Esse injeção pode ser feita diretamente no campo, mesmo que esse seja privado. Veja o exemplo de uma action que recebe através do InjectionFilter o nosso motor.

Code:
 
 public class MinhaAction extends BaseAction {
 
    private Motor motor;
 
    public String execute() throws Exception {
 
       System.out.println("Ligando o motor...");
 
       motor.ligar();
 
    }
 
 }
 
 


Além de deixar o seu código bem mais limpo e claro, o grande barato de IoC é que se amanhã vc quiser mudar o seu motor, digamos para um motor 1.8, vc não precisa tocar no seu código. Tudo que vc precisa fazer é ir na sua configuração (ApplicationManager.java) e mudar uma linha de código:

Code:
 
 ioc("motor", Motor18.class);
 
 


Espero que vc tenha entendido o ganho de flexibilidade, organização e clareza que o IoC pode proporcionar aos seus projetos.

Um outro exemplo, utilizado na aplicação demo MyBooks, é usar IoC com DAO de forma que se amanhã vc quizer trocar de banco de dados, tudo que vc precisa fazer é reconfigurar os componentes de DAO para as novas implementações.

Ex:

Code:
 
 ioc("userDAO", MySqlUserDAO.class);
 
 // mudando para Oracle
 
 ioc("userDAO", OracleUserDAO.class);
 
 



Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

2) Como consigo pegar o endereço de IP da requisição ?

A interface org.mentawai.core.Input possui o método getProperty(String name);.

Code:
 
 String ip = input.getProperty("remoteAddr"); // chama por reflection req.getRemoteAddr();
 
 String host = input.getProperty("remoteHost"); // chama por reflection req.getRemoteHost();
 
 String method = input.getProperty("method"); // chama por reflection req.getMethod();
 
 // ou seja, vc consegue obter qualquer propriedade do objeto que está por trás do input, 
 // o que no caso de um InputRequest é o HttpServletRequest.
 
 


Repare que por motivo de conveniência, esses métodos já retornam uma String ao invés de Object.

Vale notar que, apesar de não-recomendável, vc pode obter o HttpServletRequest dentro da sua action usando o código abaixo:

Code:
 
 HttpServletRequest req = ( (SessionContext) session).getRequest();
 
 


Isso não é recomendável pois vc estará atrelando a sua action a API de servlets, o que dificultará testes e reduzirá a flexibilidade do seu código.


Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

3) Como faço para pegar o diretório raiz da minha aplicação web ???

Code:
 
 String path = ApplicationManager.getRealPath();
 
 


retorna por exemplo:

c:\program files\tomcat\webapps\myapplication (windows)

ou

/usr/local/bin/tomcat/webapps/myapplication (linux)


Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

4) Como faço para pegar o HttpServletRequest de dentro da minha action ???

Apesar disso ser totalmente não-recomendável, pois você estará acoplando o seu código a API de servlets, você pode obter o HttpServletRequest através do código abaixo:

Code:
 
 HttpServletRequest req = ( (SessionContext) session).getRequest();
 
 




Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

5) Como usar o DIFilter junto com o IoCFilter ?

A diferença entre IoC e DI é simples: IoC (Inversão de Controle) é o responsável pela criação e pelo controle do ciclo de vida de um componente. Por exemplo, um componente no escopo da sessão terá uma nova instância criada automaticamente a cada nova sessão pelo IoCFilter.

Já o DI (Injeção de Dependência) é o responsável pelo interligamento dos componentes, uma vez que um componente pode depender de outro para executar sua função.

Um exemplo clássico é um DAO (Data Access Object) que depende de uma Connection para ir ao banco de dados.

Code:
 
 // definindo um componente userDao que gerará instâncias 
 // a partir da classe MySQLUserDao
 
 ioc("userDAO", MySQLUserDAO.class); 
 
 // o filtro global que transforma o Mentawai num container de IoC
 
 filter(new IoCFilter()); 
 
 // o filtro de conexão que usa um pool de conexoes por tras 
 // para prover uma conexão ao input da action...
 
 filter(new ConnectionFilter("connection", connHandler)); 
 
 // o filtro de DI que se encarrega de injetar uma Connetion 
 // em todos os componentes que precisam de uma connection
 
 filter(new DIFilter("connetion", Connection.class)); 
 
 


Note que o DIFilter vai buscar a dependência no input da action, utilizando a chave "connection".

Repare que o DIFilter pode e deve ser um filtro global, de forma que todas as action terão seus componentes automaticamente completados com suas dependências. (auto-wiring)




Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

6) Qual a diferença de um filtro PULL para um filtro PUSH ?

Nas primeiras versões do Mentawai, todos os filtros eram PUSH, isto é, os filtros empurravam os dados para o input da action, mesmo que a action não os requisitasse.

Por exemplo, um filtro de conexão (ConnectionFilter) iria colocar uma conexão no input da action sempre que ele fosse executado, mesmo que a action nunca viesse a necessitar da conexão. Dessa forma se quiséssemos colocar o filtro de conexão como global, teríamos que aceitar esse efeito colateral, ou seja, algumas actions teriam que receber uma conexão em seu input, mesmo sem precisar.

A abordagem PULL é mais eficiente e limpa. Um filtro PULL só irá colocar um dado no input da action, no momento em que esse for requisitado do input, ou seja, se ele nunca for requisitado do input o filtro fica inócuo (sem efeito). PULL em inglês significa puxar, isto é, se a action não puxar os dados nada acontece.

Além de mais eficiente, esse tipo de abordagem permite que a maioria dos filtros sejam configurados como globais, reduzindo e simplificando a configuração das actions no ApplicationManager.

Obs: As versões PUSH dos filtros IoCFilter, DIFilter, VOFilter, ConnectionFilter e InjectionFilter foram depreciados e renomeados para PushIoCFilter, DependencyFilter, PushVOFilter, PushConnectionFilter e PushInjectionFilter.

Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

7) Como fazer o JSTL funcionar ?

Isso deveria estar no FAQ do JSTL, mas como 10 de cada 10 pessoas que iniciam com JSTL tem essa dúvida aí vai a solução rápida:

Code:
 
 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 <%@ page isELIgnored="false"%>
 


ATUALIZADO: Parece que mudando a versão para 2.4 no web.xml tb resolve.



Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

8 ) Como usar as tags de paginação do Mentawai ?

Exemplo: http://paginator.mentaframework.org/

Código: http://www.mentaframework.org/examples/PaginatorTag.war

Code:
 <mtw:paginator size="5" value="myList">
 
     <mtw:isEmpty negate="true">
 	
 	<h5>Results <mtw:resultFrom /> - <mtw:resultTo /> of about <mtw:resultTotal /></h5>
 		
     </mtw:isEmpty>
 
     <mtw:hasPrevious>
         
         <a href="/HelloPaginator.mtw?page=<mtw:out />"><b>Prev</b></a>  
         
     </mtw:hasPrevious>
     
     <mtw:pageNumbers pagesToShow="3">
     
         <mtw:isCurrPage>
             <mtw:out />  
         </mtw:isCurrPage>
         
         <mtw:isCurrPage negate="true">
             <a href="/HelloPaginator.mtw?page=<mtw:out />"><mtw:out /></a>  
         </mtw:isCurrPage>
     
     </mtw:pageNumbers>
     
     <mtw:hasNext>
         
         <a href="/HelloPaginator.mtw?page=<mtw:out />"><b>Next</b></a>
         
     </mtw:hasNext>
     
     <br><br>
     
     <font color="blue">
     
     <mtw:loop>
     
         <mtw:out /><br>
         
     </mtw:loop>
     
     </font>
 
 </mtw:paginator>
 

Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

9 ) Como configurar sua action dentro da própria action, num esquema parecido com annotations?

Embora não seja recomendável, uma vez que vc estará colocando configuração dentro do código fonte da sua aplicação, vc pode configurar as suas actions na própria action através da interface Configurable.

AppManager:

Code:
 
 import java.util.*;
 
 import org.mentawai.core.*;
 import org.mentawai.i18n.*;
 
 public class ApplicationManager extends org.mentawai.core.ApplicationManager {
     
     
     public void init(Context application) {
         
         configureActions("examples.paginator");
             
     }
 
     public void loadActions() {
 
         // normal... (filtros globais, qualquer configuração de uma action, etc)
 
    }
 	
 }
 
 



Action:

Code:
 
 package examples.paginator;
 
 import java.util.*;
 
 import org.mentawai.core.*;
 
 public class HelloPaginator extends BaseAction implements Configurable {
     
     private static final List LIST = new ArrayList();
     
     static {
         
         for(int i=0;i<100;i++) LIST.add("Mentawai" + i);
         
     }
 
     public String execute() throws Exception {
 
         output.setValue("myList", LIST);
         
         return SUCCESS;
         
     }
     
     public void configure(ApplicationManager appManager) {
         
         appManager.action(HelloPaginator.class)
             .on(SUCCESS, new Forward("list.jsp"));
         
     }
 }
 
 





Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

10 ) Como trabalhar com cookies?

O Mentawai suporta cookies de uma maneira prática e eficiente através do org.mentawai.core.CookieContext, que é um org.mentawai.core.Context presente automaticamente em todas as actions que herdam de BaseAction via o membro protected cookies.

Você também pode pegar esse context através do método getCookies() da interface org.mentawai.core.Action.

Veja os exemplos abaixo:

Code:
 
 // dentro de qualquer action que estende BaseAction:
 
 cookies.setAttribute("meucookie", "hi"); // envia um cookie para o cliente
  
 cookies.removeAttribute("meucookie"); // fala para o browser remover esse cookie
  
 cookies.getAttribute("meucookie"); // retorna o valor do cookie, que é uma string
 
 // para pegar o CookieContext de um action faz-se assim:
 
 Context cookies = action.getCookies();
 
 // e para um maior controle vc pode adicionar um objeto Cookie da especificação de Servlets diretamente no contexto:
 
 Cookie c = new Cookie("asdfdsaf", "asdf");
 c.setMaxAge(232323);
 c.setPath("/");
  
 cookies.setAttribute("meucookie", c);
 
 



Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

11 ) Como suportar de forma simples CoC (Convention over Configuration) para a camada view, de forma que você não precise configurar as páginas de destino da sua action?

Apesar de acreditarmos que CoC para a camada view só é viável em projetos pequenos e muitos simples, o Mentawai oferece essa funcionalidade de maneira bastante fácil.

Se você esquecer ou propositalmente não especificar uma consequência para uma action, o Mentawai criará uma consequência do tipo Forward automaticamente seguindo a convenção abaixo:

Code:
 
 Action sendo executada = HelloMentawai.mtw
 
 - Action retornou SUCCESS: new Forward("/HelloMentawai/ok.jsp");
 
 - Action retornou ERROR: new Forward("/HelloMentawai/error.jsp");
 
 - Action retornou qualquer resultado X: new Forward("/HelloMentawai/X.jsp");
 
 
 InnerAction sendo executada = HelloMentawai.sayhello.mtw
 
 - Action retornou SUCCESS: new Forward("/HelloMentawai/sayhello.ok.jsp");
 
 - Action retornou ERROR: new Forward("/HelloMentawai/sayhello.error.jsp");
 
 - Action retornou qualquer restulado X: new Forward("/HelloMentawai/sayhello.X.jsp");
 
 


Observação: Essa funcionalidade está ativada por default. Entretanto se você preferir que o controlador jogue uma exception ao invés de tentar usar o esquema acima, você pode desativar esse CoC através do método do ApplicationManager setAutoView(false);

Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

12 ) Como criar minhas próprias tags utilizando o Mentawai?

Qualquer projeto sério exigirá o desenvolvimento de novas tags para a camada view, pois sempre haverá uma complexidade ou lógica que você não deve deixar "jogada" no meio do HTML.

O Mentawai suporta de uma maneira muito simples e eficiente a criação de novas tags que já estarão automaticamente integradas com o framework. Veja os exemplos abaixo:

org.mentawai.tag.util.PrintTag: Tag para imprimir alguma coisa na tela.

Code:
 
 public class PrintSomething extends PrintTag {
     
         @Override
 	public String getStringToPrint() throws JspException {
 
             String s = getMyString(); // lógica louca e complexa para obter sua string está aqui...
 
             return s;
 
         }
 }
 


E no seu taglib.tld vc coloca: (isso é especificação da API de Servlets e não do Mentawai, é claro!)

Code:
 <tag>
 	<name>printSomething</name>
 	<tag-class>org.myproject.tag.PrintSomething</tag-class>
 	<body-content>empty</body-content>
 	<display-name></display-name>
 </tag>
 


E para usar a tag:

Code:
 <minhasTags:printSomething />
 


Além da simplicidade do código acima, o grande barato é que sua tag já terá disponível os seguintes membros protected: application (ServletContext), session (HttpSession), req (HttpServletRequest), res (HttpServletResponse), action (org.mentawai.core.Action) e loc (java.util.Locale). Vale notar que a action só será diferente de null se a página onde a tag estiver contida estiver recebendo um forward de alguma action, ou seja, se você estiver acessando a página diretamente pelo browser (Ex: http://www.mysite.com/mypage.jsp) a action será nula como tem que ser.

Outra facilidade interessante que você já recebe de mão-beijada da classe pai (PrintTag) é o atributo max, que vai limitar o tamanho da string impressa em um número máximo de caracteres, colocando "..." no final.

Para usar esse atributo nas suas tags, tudo que vc tem que fazer é adicioná-lo no arquivo tld.

Code:
 <tag>
 	<name>printSomething</name>
 	<tag-class>org.myproject.tag.PrintSomething</tag-class>
 	<body-content>empty</body-content>
 	<display-name></display-name>
 	<attribute>
 		<name>max</name>
 		<required>false</required>
 		<rtexprvalue>true</rtexprvalue>
 		<type>int</type>
 	</attribute>
 </tag>
 


E para usá-la:

Code:
 <minhasTags:printSomething max="300" />
 


org.mentawai.tag.util.ConditionalTag: Tag que só mostra o seu conteúdo se alguma condição for verdadeira.

Veja a implementação abaixo da tag do Mentawai isNull:

Code:
 package org.mentawai.tag;
 
 import javax.servlet.jsp.JspException;
 import javax.servlet.jsp.tagext.Tag;
 
 import org.mentawai.tag.util.ConditionalTag;
 import org.mentawai.tag.util.Context;
 
 public class IsNull extends ConditionalTag {
     
     private String test = null;
     
     public void setTest(String test) {
         this.test = test;
     }
     
     public boolean testCondition() throws JspException {
         
 	if (test != null) {
 
             // O atributo test está presente, então estamos querendo
             // algum valor que está no pageContext, output, session ou application
             // nessa ordem...
 
             // O ultimo parametro do método abaixo (false) serve para indicar que não queremos procurar
             // por tipos booleanos através dos métodos isMyObject (assumindo que o valor de test seja "myObject")
 			
             Object value = Out.getValue(test, pageContext, false);
             
             if (value == null) return true;
             
             return false;
 			
 	}
 
         // o atributo test não foi passado, então temos que estar falando de um contexto, ou seja,
         // deverá haver uma tag do tipo Context englobando essa tag e que fornecerá o objeto 
         // para o teste da tag isNull.
 		
 	Tag parent = findAncestorWithClass(this, Context.class);		
         
         if (parent == null) {
         	
             throw new JspException("IsNull: Could not find context!");
         	
         }
             
 	Context tag = (Context) parent;
 	
 	return tag.getObject() == null;
            
     }
 }
 


E no arquivo TLD:

Code:
 <tag>
 	<name>isNull</name>
 	<tag-class>org.mentawai.tag.IsNull</tag-class>
 	<body-content>JSP</body-content>
 	<display-name></display-name>
 	<attribute>
 		<name>negate</name>
 		<required>false</required>
 		<rtexprvalue>true</rtexprvalue>
 		<type>boolean</type>
 	</attribute>
 	<attribute>
 		<name>test</name>
 		<required>false</required>
 		<rtexprvalue>true</rtexprvalue>
 		<type>java.lang.String</type>
 	</attribute>
 </tag>
 


Repare que da mesma maneira que a tag PrintTag, a tag ConditionalTag também fornece os membros protected: application, session, req, res, action e loc.

Repare que a tag base ConditionalTag tb já implementa de mão-beijada o atributo "negate", que funciona basicamente como um ELSE, ou seja, ele é a negaçao da condiçao.

Logo para usar a tag condicional isNull vc faz:

Code:
 
 <mtw:isNull test="mySuperObject">
 
     <h1>Não consegui achar em lugar nenhum um objeto com o nome "mySuperObject"</h1>
 
 </mtw:isNull>
 
 <mtw:isNull test="mySuperObject" negate="true">
 
      <h1>Parabéns! Aqui está o objeto super object: <mtw:out value="mySuperObject" /></h1>
 
 </mtw:isNull>
 
 <mtw:bean value="mySuperObject">
 
     <mtw:isNull>
         <h1> mySuperOjbect está null! </h1>          
     </mtw:isNull>
 
     <mtw:isNull negate="true">
         <h1> mySuperOjbect não está null! </h1>          
     </mtw:isNull>
 
 </mtw:bean>
 
 


org.mentawai.tag.LoopTag: Tag para loopar itens de uma Collection qualquer!

(Coming soon...)


Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline

13 ) Como descobrir e utilizar o path do contexto da minha aplicação?

Quantas vezes não construímos aplicações num ambiente e quando colocamos em outro temos alguns problemas clássicos:

imagens não são exibidas
arquivos javascript não são carregados
links não funcionam

Isso acontece quando você referencia nos seus programas uma URL fixa, como por exemplo:

Numa aplicação /hellomenta/ temos a imagem /hellomenta/eu.gif .

Se sua aplicação tiver um HTML do tipo < img src="/hellomenta/eu.gif" > funciona sem problemas.

Mas se for usado em um contexto diferente como por exemplo /minhaapp ou para o context / (ROOT) sua imagem vai sumir!!!

Para corrigir esse problema o Mentawai fornece a tag contextPath. Portanto para a imagem funcionar com qualquer nome de aplicação, ou seja, em qualquer contexto você faz:

< img src="<mtw:contextPath/>/eu.gif" >

Usando essa tag, teríamos o seguinte resultado:

no contexto /hellomenta/ < img src="/hellomenta/eu.gif" >

no contexto /minhaapp/ < img src="/minhaapp/eu.gif" >

no context / (ROOT) < img src="/eu.gif" >

Sergio Oliveira

saoj



Joined: 01/07/2005 09:59:17
Messages: 2846
Location: Rio de Janeiro, RJ
Offline


Agora o FAQ oficial está em:

http://forum.mentaframework.org/forums/show/19.page

(vamos deixar esse post aqui sumir no horizonte...)

Sergio Oliveira

 
Forum Index -> Comentários Gerais
Go to:   
Powered by JForum 2.1.6 © JForum Team