Mentawai x Struts2

- Validação:

O Struts2 oferece validação via XML ou Annotations.

A documentação do Struts2 continua sendo, na minha opinião, pouco objetiva e pouco clara. Clique aqui para acessar a documentação oficial sobre validação, e tire suas próprias conclusões. Repare que não há nenhum código Java, apenas XML.

Validação via XML: (repare que existe código Java dentro do XML !!!!

)

<!DOCTYPE validators PUBLIC 
        "-//OpenSymphony Group//XWork Validator 1.0.2//EN" 
        "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
  
  <field name="email">
      <field-validator type="required" short-circuit="true">
          <message>You must enter a value for email.</message>
      </field-validator>
      <field-validator type="email" short-circuit="true">
          <message>Not a valid e-mail.</message>
      </field-validator>
  </field>
  
  <field name="email2">
     <field-validator type="required">
          <message>You must enter a value for email2.</message>
      </field-validator>
     <field-validator type="email">
          <message>Not a valid e-mail2.</message>
      </field-validator>
  </field>
  
  <validator type="expression">
      <param name="expression">email.equals(email2)</param>
      <message>Email not the same as email2</message>
  </validator>
  
  <validator type="expression" short-circuit="true">
      <param name="expression">email.startsWith('mark')</param>
      <message>Email does not start with mark</message>
  </validator>
</validators>

Validação via Annotations: (como deturpar o uso de annotations assim como foi feito com o uso de XML)

Clique aqui para ver que isso está na documentação oficial do Struts2

@Validation()
public class SimpleAnnotationAction extends ActionSupport {

@RequiredFieldValidator(type = ValidatorType.FIELD, message = "You must enter a value for bar.")
    @IntRangeFieldValidator(type = ValidatorType.FIELD, min = "6", 
     max = "10", message = "bar must be between ${min} and ${max}, current value is ${bar}.")
    public void setBar(int bar) {
        this.bar = bar;
    }

public int getBar() {
        return bar;
    }

@Validations(
            requiredFields =
                    {@RequiredFieldValidator(type = ValidatorType.SIMPLE, 
fieldName = "customfield", message = "You must enter a value for field.")},
            requiredStrings =
                    {@RequiredStringValidator(type = ValidatorType.SIMPLE,
 fieldName = "stringisrequired", message = "You must enter a value for string.")},
            emails =
                    { @EmailValidator(type = ValidatorType.SIMPLE, 
fieldName = "emailaddress", message = "You must enter a value for email.")},
            urls =
                    { @UrlValidator(type = ValidatorType.SIMPLE, 
fieldName = "hreflocation", message = "You must enter a value for email.")},
            stringLengthFields =
                    {@StringLengthFieldValidator(type = ValidatorType.SIMPLE, trim = true, minLength="10" , 
maxLength = "12", fieldName = "needstringlength", message = "You must enter a stringlength.")},
            intRangeFields =
                    { @IntRangeFieldValidator(type = ValidatorType.SIMPLE, 
fieldName = "intfield", min = "6", max = "10", message = "bar must be between ${min} and ${max}, current value is ${bar}.")},
            dateRangeFields =
                    {@DateRangeFieldValidator(type = ValidatorType.SIMPLE, 
fieldName = "datefield", min = "-1", max = "99", message = "bar must be between ${min} and ${max}, current value is ${bar}.")},
            expressions = {
                @ExpressionValidator(expression = "foo > 1", 
message = "Foo must be greater than Bar 1. Foo = ${foo}, Bar = ${bar}."),
                @ExpressionValidator(expression = "foo > 2", 
message = "Foo must be greater than Bar 2. Foo = ${foo}, Bar = ${bar}."),
                @ExpressionValidator(expression = "foo > 3", 
message = "Foo must be greater than Bar 3. Foo = ${foo}, Bar = ${bar}."),
                @ExpressionValidator(expression = "foo > 4",
 message = "Foo must be greater than Bar 4. Foo = ${foo}, Bar = ${bar}."),
                @ExpressionValidator(expression = "foo > 5",
 message = "Foo must be greater than Bar 5. Foo = ${foo}, Bar = ${bar}.")
    }
    )
    public String execute() throws Exception {
        return SUCCESS;
    }
}

Mais uma vez a configuração programática do Mentawai mostra todo o seu poder facilitando a implementação dessa funcionalidade tão essencial e importante:

Filtro de Validação do Mentawai: (pode ser aplicado em mais de uma action)

Ou vc pode também fazer a validação diretamente na action através da interface Validatable: http://recipes.mentaframework.org/posts/list/4.page

public class HelloWorldValidator extends ValidationFilter {

private static final String FIELD_REQUIRED_ERROR = "Field required!";
    private static final String INVALID_USERNAME_LENGTH = "Username length invalid!";
    private static final String INVALID_AGE = "Invalid age!";
    private static final String INVALID_PASSWORD_LENGTH = "Invalide password length!";
    private static final String PASSWORD_DOES_NOT_MATCH = "Passwords do not match!";

public void initValidator() {
        
        add("username", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("username", new StringRule(6, 30), INVALID_USERNAME_LENGTH);
        
        add("age", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("age", new IntegerRule(18, 50), INVALID_AGE);
        
        add("password", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("password", new StringRule(4, 20), INVALID_PASSWORD_LENGTH);
        add("password", new EqualRule("password", "passconf"), PASSWORD_DOES_NOT_MATCH);
        
        add("passconf", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
    }

}

E para internacionalizar essas mensagens, tudo que vc precisa fazer é criar um arquivo HelloWorldValidator_en_US.i18n dentro do diretório /validation:

E o filtro de validação ficaria assim:

public class HelloWorldValidator extends ValidationFilter {

private static final String FIELD_REQUIRED_ERROR = "required"; // to illustrate that this can be a string too
    private static final int INVALID_USERNAME_LENGTH = 2;
    private static final int INVALID_AGE = 3;
    private static final int INVALID_PASSWORD_LENGTH = 4;
    private static final int PASSWORD_DOES_NOT_MATCH = 5;

public void initValidator() {
        
        add("username", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("username", new StringRule(6, 30), INVALID_USERNAME_LENGTH);
        
        add("age", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("age", new IntegerRule(18, 50), INVALID_AGE);
        
        add("password", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
        add("password", new StringRule(4, 20), INVALID_PASSWORD_LENGTH);
        add("password", new EqualRule("password", "passconf"), PASSWORD_DOES_NOT_MATCH);
        
        add("passconf", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
    }

}

- Internacionalização:

A documentação oficial do Struts para internacionalização está aqui: http://struts.apache.org/2.x/docs/localization.html

Mais uma vez a documentação deixa em aberto as seguintes questões:

- Struts2 utiliza ResourceBundle, o que provavelmente vai forçar um restart da aplicação a cada mudança nos arquivos properties do resourcebundle.

- Se o locale do meu usuário está salvo no banco, como forço para que o locale da aplicação seja esse locale para esse usuário?

- Tenho a opção de criar apenas um único arquivo onde todo o meu conteúdo internacionalizado estará presente (arquivo master) ?

- O Struts2 permite internacionalizar actions colocando arquivos properites dentro do pacote da action. É boa prática colocar os arquivos de internacionalização separados do seu código e num lugar que possa ser acessível pelo designer e/ou tradutor. (Ou vc programador vai fazer essa tarefa?)

Compare o approach do Struts2 com o approach do Mentawai e tire suas próprias conclusões: http://www.mentaframework.org/i18n.jsp?loc=pt

- Conversão:

Assim como sua documentação, os conversores do Struts não são nem simples, nem claros, nem pragmáticos:

É difícil entender e/ou justficar algo tão bizarro acima para algo tão simples como uma conversão, principalmente quando olhamos a versão do Mentawai abaixo:

- Filtros:

A configuração dos filtros é feita via XML, como sempre. Se tivermos que por exemplo aplicar o mesmo filtro em 100 actions diferentes, teremos que usar copy/paste e transformar a nossa configuração num arquivo XML gigantesco. Em contrapartida, se utilizarmos configuração programática, podemos fazer um for/loop, métodos, if, etc.

Veja o exemplo de um interceptor do Struts:

Reparem que, talvez pela falta de um INPUT/OUTPUT para as actions, o interceptor acima está fortemente acoplado a action MyAction, ou seja, só pode ser aplicado a ela.

Na versão do Mentawai ficaria assim:

(reparem que o filtro abaixo poderá ser aplicado em qualquer action, e não apenas MyAction)

Aguardem mais comparativos !!!