Skip to main content
Here's a script from the Groovy book that explains expandos and makes some sense of why you might want to mess with spinning up methods at runtime. - http://groovy.codehaus.org/ExpandoMetaClass+-+Dynamic+Method+Names

The first example might help you pull off some interactive UI.
The second lends to a more fluid api. 
Run that in your console and smoke it.

import org.springframework.web.util.HtmlUtils

class HTMLCodec {
    static encode = { theTarget ->
        HtmlUtils.htmlEscape(theTarget.toString())
    }

    static decode = { theTarget ->
    HtmlUtils.htmlUnescape(theTarget.toString())
    }
}
//So what we do with these classes is to evaluate the convention and add 
//"encodeAsXXX" methods to every object based on the first part of the 
//name of the codec class such as "encodeAsHTML". The pseudo code to achieve this is below:
def classes = [HTMLCodec]



def codecs = classes.findAll { it.name.endsWith('Codec') }

codecs.each { codec ->
    Object.metaClass."encodeAs${codec.name-'Codec'}" = { codec.newInstance().encode(delegate) }
    Object.metaClass."decodeFrom${codec.name-'Codec'}" = { codec.newInstance().decode(delegate) }
}


def html = '<html><body>hello</body></html>'

println '&lt;html&gt;&lt;body&gt;hello&lt;/body&gt;&lt;/html&gt;' == HtmlUtils.htmlEscape(html)
//vs.
println '&lt;html&gt;&lt;body&gt;hello&lt;/body&gt;&lt;/html&gt;' == html.encodeAsHTML()


println html.encodeAsHTML()

Comments

Popular posts from this blog

Microservices Design Patterns

functional decomposition or domain-driven design well-defined interfaces  explicitly published interface  single responsibility principle potentially polyglot http://blog.arungupta.me/microservice-design-patterns/ http://blog.arungupta.me/microservices-monoliths-noops/ https://go.forrester.com/blogs/13-11-20-mobile_needs_a_four_tier_engagement_platform/ three-tier architecture — presentation, application, data vs. 4 tier -- client, delivery, aggregation, services

JSON stores and Aggregation for system logs and audit trail. Stop logging with format strings!

This first article explains why you might want to store logs and BI data in a machine readable format. https://journal.paul.querna.org/articles/2011/12/26/log-for-machines-in-json/ The second two get at how you might do that and be able to transition/re-purpose your existing relational stores into a cloud based scalable framework.  http://docs.mongodb.org/ecosystem/tutorial/use-aggregation-framework-with-java-driver/ http://www.bityota.com/3-steps-to-analytics-on-mongodb/ Logging might present a relatively low profile target for schema-less implementation and give you a chance to expose your organization to an important technology for modern web development. With your foot in the door you might convince them to add usage auditing and before you know it you are doing up front analysis on usage in front of your next project.