Validators are candidates for object extraction however Grails expects a validator to be a closure. I would still consider extracting this to an object for example

```
static constraints = {
    start blank: false
    end blank: false
    start validator: DateFormatValidator.valid
    end   validator: DateFormatValidator.valid
}

class DateFormatValidator {
 
    static def valid = {
 
        try {
            DateTimeFormatter fmt = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
            fmt.parseDateTime(it)

            return true
        }
        catch (Exception e) {

            return false
        }
    }
}
```

I think the validation code itself can be refactored a little too. Do we have a policy with regard to multiple returns? My personal preference is to have an explicit `return` at the end of a method if it is returning regardless of path, so something like 

```
static def dateFormatValidator = {
    def isValid = false
    try {
        DateTimeFormatter fmt = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
        fmt.parseDateTime(it)

        isValid = true
    }
    catch (Exception e) { }

    return isValid
}
``` 
or,

```
static def dateFormatValidator = {
    try {
        DateTimeFormatter fmt = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
        fmt.parseDateTime(it)

        return true
    }
    catch (Exception e) { }

    return false
}
```

Consider using the extract temporary variable refactoring as well by either inlining or creating a method;

```
static def dateFormatValidator = {

    try {
        DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").parseDateTime(it)
        return true
    }
    catch (Exception e) { }

    return false
}
```

or

```
static def dateFormatValidator = {
    try {
        dateValidationFormat().parseDateTime(it)

        return true
    }
    catch (Exception e) { }

    return false
}

static def dateValidationFormat() {
    return DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
}
```

Then I think with either approach we can start to rely on Groovy truth?

```
static def dateFormatValidator = {
    try {
        return dateValidationFormat().parseDateTime(it) as Boolean
    }
    catch (Exception e) { }

    return false
}
```

```
static def dateFormatValidator = {
    try {
        return DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").parseDateTime(it) as Boolean
    }
    catch (Exception e) { }

    return false
}
```