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

Banana Monkey Jungle

Why functional over OO? https://medium.com/@cscalfani/goodbye-object-oriented-programming-a59cda4c0e53 Inheritance Banana Monkey Jungle The diamond relationship Fragile parent class Categorical (Taxonomy) v.  Containment (or Exclusive Ownership) Hierarchies Encapsulation Object passed by reference to an Object Constructor is not safe Deep cloning MC Hammer v.   Immutability Global Scope Polymorphism https://www.cs.utexas.edu/~mitra/csSummer2013/cs312/lectures/interfaces.html Design by Behavior not Data

Build software like you build houses

Interfaces facilitate visibility. Software is the only engineering practice that doesn't allow runtime visibility to end-user. If this were true for construction, it would mean your builder would have to live with you for you to even guess what the problem is. https://vimeo.com/221049715 https://github.com/stripe/veneur