CODEWITHSUNDEEP
grailsgroovy
Ricardo Gladwell
Ricardo Gladwell

Reputation: 3787

What are the alternatives to overriding asType() when writing conversion code?

It appears the convention for converting objects in Groovy is to use the as operator and override asType(). For example:

class Id {
    def value

    @Override
    public Object asType(Class type) {
        if (type == FormattedId) {
            return new FormattedId(value: value.toUpperCase())
        }
    }
}

def formattedId = new Id(value: "test") as FormattedId

However, Grails over-writes the implementation of asType() for all objects at runtime so that it can support idioms like render as JSON.

An alternative is to re-write the asType() in the Grails Bootstrap class as follows:

def init = { servletContext ->
    Id.metaClass.asType = { Class type ->
        if (type == FormattedId) {
                return new FormattedId(value: value.toUpperCase())
        }
    }
}

However, this leads to code duplication (DRY) as you now need to repeat the above in both the Bootstrap and the Id class otherwise the as FormattedId will not work outside the Grails container.

What alternatives exist to writing conversion code in Groovy/Grails that do not break good code/OO design principals like the Single Responsibility Principal or DRY? Are Mixins are good use here?

Upvotes: 6

Views: 1417

Answers (2)

Nancy Deschênes
Nancy Deschênes

Reputation: 365

My un-elegant solution is to rename the original asType(), and make a new asType() that calls it, and to also make your BootStrap overwrite astType with a call to that method:

so, your class:

class Id {
    def value

    @Override
    public Object asType(Class type) {
        return oldAsType(type);
    }

    public Object oldAsType(Class type) {
        if (type == FormattedId) {
            return new FormattedId(value: value.toUpperCase())
        }
    }
}

In my app, I had asType defined in a number of classes, so I ended up using a common closure in BootStrap.groovy:

    def useOldAsType = {Class clazz ->
        delegate.oldAsType(clazz)
    }

    Id.metaClass.asType = useOldAsType;
    Value.metaClass.asType = useOldAsType;
    OtherClass.metaClass.asType = useOldAsType;
    SubclassOfValue.metaClass.asType = useOldAsType;

Note that if you have a subclass that does not override asType, but you want it to use the superclass's, you must also set it in BootStrap.

Upvotes: 0

Ricardo Gladwell
Ricardo Gladwell

Reputation: 3787

You can use the Grails support for Codecs to automatically add encodeAs* functions to your Grails archetypes:

class FormattedIdCodec {

    static encode = { target ->
        new FormattedId((target as String).toUpperCase()
    }

}

Then you can use the following in your code:

def formattedId = new Id(value: "test").encodeAsFormattedId

Upvotes: 1

Related Questions