title: Dynamic object method invocation using reflection in scala
body: <p>I'm looking to create a way to dynamically call logic depending on template id within scala. So template id 1 calls logic a, template id 2 call logic b, etc. The logic will be diverse but will have the same inputs/outputs. Also the number of different template ids will get into the thousands and will not be known ahead of time, so a loose coupling feels the way to go.</p>
  
  <p>I've started looking at reflection to do this using scala 2.11.1 and can statically use reflection when I know the logic to be used ahead of time but have not found the correct way to dynamically use reflection, so for example passing in template id 2 will call logic b.</p>
  
  <p>Below is a cut down example showing how the static version works and the skeleton I have so far for the dynamic version.</p>
  
  <pre><code>package thePackage
  
  import scala.reflect.runtime.{universe =&gt; ru}
  
  trait theTrait { def theMethod(x: String): Unit }
  
  // the different logic held in different objects
  object object1 extends theTrait {
    def theMethod(x: String) = { println("a " + x ) }
  }
  
  object object2 extends theTrait { 
    def theMethod(x: String) = { println("b " + x ) }
  }
  
  object object3 extends theTrait {
    def theMethod(x: String) = { println("c " + x ) }
  }
  
  // run static/dynamic reflection methods
  object ReflectionTest {
  
    // "static" invocation calling object1.theMethod
    def staticInvocation() = {
      val m = ru.runtimeMirror(getClass.getClassLoader)
      val im = m.reflect(thePackage.object1)
      val method = ru.typeOf[thePackage.object1.type]
                     .decl(ru.TermName("theMethod")).asMethod
      val methodRun = im.reflectMethod(method)
      methodRun("test")
    }
  
    staticInvocation
  
    // "dynamic" invocation using integer to call different methods
    def dynamicInvocation( y: Integer) = {
      val m = ru.runtimeMirror(getClass.getClassLoader)
      val module = m.staticModule("thePackage.object" + y)
      val im = m.reflectModule(module)
  
      //  stuck... static approach does not work here
  
    }
  
    dynamicInvocation(1)
    dynamicInvocation(2)
    dynamicInvocation(3)
  
  }
  </code></pre>
  
  <p>What needs to be added/changed to the dynamicInvocation method to make this work, or should I be using a different approach?</p>