Overview

Struts2 provides multiple mechanisms for validating input data such as email addresess, numeric ranges, and date formats. There are three primary validation approaches: using the validate() method, XML-based validation, and annotation-based validation. 1. Basic Setup

Define a User class with standard fields and accessors: ```

package com.example.demo;

import java.util.Date;

public class User { private String name; private int age; private String email; private Date birthDay;

// Standard getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }

public int getAge() { return age; }
public void setAge(int age) { this.age = age; }

public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }

public Date getBirthDay() { return birthDay; }
public void setBirthDay(Date birthDay) { this.birthDay = birthDay; }

}

</div>2. Programmatic Validation Using validate()
-------------------------------------------

Overrride the `validate()` method in an `ActionSupport` subclass to perform validation logic before execution. <div class="code-block">```

package com.example.demo;

import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.opensymphony.xwork2.ActionSupport;

public class ValidateUserAction extends ActionSupport {
    private User user;

    public String execute() {
        if (user == null || hasFieldErrors()) {
            return "register";
        }
        return "success";
    }

    public void validate() {
        if (user != null) {
            if (!isValidName(user.getName())) {
                addFieldError("user.name", "Name must start with a letter and contain only letters, numbers, underscores");
            }

            if (!isValidAge(user.getAge())) {
                addFieldError("user.age", "Age must be between 0 and 120");
            }

            if (!isValidEmail(user.getEmail())) {
                addFieldError("user.email", "Email format is invalid");
            }

            if (!isBirthDateValid(user.getBirthDay())) {
                addFieldError("user.birthDay", "Birth date must be between 1900-01-01 and 2017-01-01");
            }
        }
    }

    private boolean isValidName(String name) {
        return name != null && name.matches("^[A-Za-z][A-Za-z1-9_-]+$");
    }

    private boolean isValidAge(int age) {
        return age >= 0 && age <= 120;
    }

    private boolean isValidEmail(String email) {
        String regex = "^[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\\.){1,3}[a-zA-z\\-]{1,}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    private boolean isBirthDateValid(Date date) {
        Date min = parseDate("1900-01-01");
        Date max = parseDate("2017-01-01");
        return !(date.before(min) || date.after(max));
    }

    private Date parseDate(String dateStr) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        ParsePosition pos = new ParsePosition(0);
        return formatter.parse(dateStr, pos);
    }

    public User getUser() { return user; }
    public void setUser(User user) { this.user = user; }
}

To avoid repteitive code in actions, Struts2 supports XML-based validation files. Create a file named ValidateUserAction-validation.xml in the same package as the action class. ```

<field name="user.email">
    <field-validator type="email">
        <message>Email address is not valid</message>
    </field-validator>
</field>

<field name="user.age">
    <field-validator type="int">
        <param name="min">0</param>
        <param name="max">120</param>
        <message>Age must be between 0 and 120</message>
    </field-validator>
</field>

<field name="user.birthDay">
    <field-validator type="date">
        <param name="min">1900-01-01</param>
        <param name="max">2017-01-01</param>
        <message>Birth date must be between ${min} and ${max}</message>
    </field-validator>
</field>

</div>4. Annotation-Based Validation
------------------------------

Use annotations to declare validation rules directly on the action class. <div class="code-block">```

package com.example.demo;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.validator.annotations.*;

@Validations(
    emails = {
        @EmailValidator(fieldName = "user.email", message = "Email format is invalid")
    },
    intRangeFields = {
        @IntRangeFieldValidator(fieldName = "user.age", min = "0", max = "120", message = "Age must be between 0 and 120")
    },
    dateRangeFields = {
        @DateRangeFieldValidator(fieldName = "user.birthDay", min = "1900-01-01", max = "2017-01-01", message = "Birth date must be between 1900-01-01 and 2017-01-01")
    },
    regexFields = {
        @RegexFieldValidator(regexExpression = "^[A-Za-z][A-Za-z1-9_-]+$", fieldName = "user.name", message = "Name must start with a letter and contain only letters, numbers, or underscores")
    }
)
public class ValidateUserAction extends ActionSupport {
    private User user;

    public String execute() {
        return "success";
    }

    public User getUser() { return user; }
    public void setUser(User user) { this.user = user; }
}