Mentawai Web Framework

Inner Actions

Uma action pode ter outras sub-actions ou inner actions na sua implementação. A funcionalidade principal de uma action é definida pelo seu método execute(), mas você também pode criar outros métodos para implementar diferentes funcionalidades dentro da classe da action.

Abaixo temos um exemplo da implementação de uma action que implementa também uma inner action:

public class HelloInnerActions extends BaseAction {
	
	public String execute() throws Exception {
		output.setValue("speak", "Hello there!");
		return SUCCESS;
	}
	
	public String sayBye() throws Exception {
		output.setValue("speak", "Bye for now...");
		return SUCCESS;
	}
	
}
			

Para chamar uma inner action, você adiciona o seu nome logo antes da extensão do Mentawai na URL da action. Exemplos:

http://www.yourapp.com/HelloInnerActions.sayBye.mtw
http://www.yourapp.com/yourcontext/categories.add.mtw?id=10

Uma inner action pode ter suas próprias consequencias e filtros, e isso pode ser definido independentemente das consequencias e dos filtros da action regular (action regular = método execute). Verifique os exemplos abaixo:

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
	
    public void loadActions() {
        
        // Example 1)
        
        // Define an action config for a regular action (execute() method)
        // and you can call any inner action that it will use the configuration
        // of the regular action
        
        ActionConfig ac = new ActionConfig("/HelloInnerAction", HelloInnerActions.class);
        ac.addConsequence(HelloMentawai.SUCCESS, new Forward("/hello.jsp"));
        addActionConfig(ac);

        // Example 2)
        // You can define an inner action consequence, 
        // to be used instead of the regular action consequence...
        
        ac = new ActionConfig("/HelloInnerAction2", HelloInnerActions.class);
        ac.addConsequence(HelloMentawai.SUCCESS, new Forward("/hello2.jsp"));
        ac.addConsequence(HelloMentawai.SUCCESS, "sayBye", new Forward("/bye2.jsp"));
        addActionConfig(ac);        
        
        // Example 3)
        // You can define an inner action config, 
        // so that consequences and filters can be defined solely for this inner action...
        
        ac = new ActionConfig("/HelloInnerAction3", HelloInnerActions.class, "sayBye");
        ac.addConsequence(HelloMentawai.SUCCESS, new Forward("/hello3.jsp"));
        
        // this line below will thrown an exception
        // it doesn't make sense to define an inner action consequence of an inner action config...
        ac.addConsequence(HelloMentawai.SUCCESS, "sayBye", new Forward("/bye3.jsp")); // exception...
        
        // adding a filter, which will apply only for this inner action
        ac.addFilter(new SayByeValidationFilter());
        addActionConfig(ac);                
    }
}
	

No exemplo 1) nós estamos definindo uma configuração regular de action com uma consequencia regular. Note que a classe HelloInnerActions pode implementar também uma inner action "sayBye" e nada impede você de chama-la com a URL /HelloInnerActions.sayBye.mtw. Como você não declarou nenhuma consequencia específica para sua inner action "sayBye", ela por padrão utilizará as consequencias regulares.

No exemplo 2) nós estamos definindo uma configuração de action regular, mas desta vez estamos definindo uma consequencia de inner action. Um inner action primeiro checa pela suas próprias consequencias. Caso não as encontre, então ela usa as consequencias da action regular.

In exemplo 3) nós estamos definindo uma configuração de inner action, logo todas as consequencias e filtros para essa configuração de action serão específicas para essa inner action. Não existe nenhuma action regular aqui, portanto se chamar /HelloInnerAction3.mtw o controlador lançará uma ActionNotFoundException. Note também que para exemplo 3) não faz sentido definir uma consequencia de inner action, já que todas as consequencias são por definição para a inner action especificada na configuração da action.

Se preferir, você pode definir novos resultados para diferenciar entre actions regulares e inner actions.Veja o exemplo abaixo:

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
	
    public void loadActions() {

        ActionConfig ac = new ActionConfig("/HelloInnerAction", HelloInnerActions.class);
        // this can be returned by the execute() method...
        ac.addConsequence(HelloMentawai.HELLO, new Forward("/hello.jsp"));
        // this can be returned by the sayBye() method...
        ac.addConsequence(HelloMentawai.BYE, new Redirect("/bye.jsp"));
        addActionConfig(ac);
        
    }
}
	
Você pode clicar aqui para baixar um exemplo de aplicação que mostra o uso das inner actions.