How do I call a Scala Object method using reflection?

Question

say, I have the following:

trait SomeTrait {
  def someMethod: String;
}

object SomeObject extends SomeTrait {
  def someMethod = "something";
}

I would like to call "someMethod" using reflection as I have the object name as a String. Something like:

val objectName = "SomeObject"  
val someTrait:SomeTrait = ???.asInstanceOf[SomeTrait]  
someTrait.someMethod

or something similar.

Thanks

score 25 · Answer 1 · answered Jun 15 '10 at 07:35

25

def companion[T](name : String)(implicit man: Manifest[T]) : T = 
    Class.forName(name + "$").getField("MODULE$").get(man.erasure).asInstanceOf[T]

val result = companion[SomeTrait]("SomeObject").someMethod

answered Jun 15 '10 at 07:35

Thomas Jung

32,428
9
84
114

This is even better. Thanks Thomas. – sanjib Jun 15 '10 at 17:11
2

Do you need the manifest? I found that `Class.forName(name + "$").getField("MODULE$").get(null)` is sufficient. This is allowed for static fields. – 0__ Jun 01 '13 at 17:44
3

How does it translate in 2.10 with reflection? – bhericher Jun 27 '13 at 14:15
Using Scala 2.10.2, my code threw an exception on `Class.forName(name + "$").getField("MODULE$")` – Kevin Meredith Feb 05 '14 at 18:51
@Thomas Jung , what is the "$" here , what it refer too , sorry me new to scala. – BdEngineer Oct 25 '18 at 14:45

score 20 · Answer 2 · answered Dec 14 '15 at 06:29

Since scala 2.10, we can use the reflection of Module:

import scala.reflect.runtime.universe

val runtimeMirror = universe.runtimeMirror(getClass.getClassLoader)
val module = runtimeMirror.staticModule("SomeObject")
val obj = runtimeMirror.reflectModule(module)
val someTrait:SomeTrait = obj.instance.asInstanceOf[SomeTrait]  
someTrait.someMethod

score 15 · Answer 3 · answered Jun 14 '10 at 19:41

For classes, this can be done pretty easily using the standard java reflection classOf method. For Scala objects, it is a bit more work, but it still can be done:


trait SomeTrait { def someMethod: String}
object SomeObject extends SomeTrait { def someMethod = "something"}

class SomeClass extends SomeTrait { def someMethod = "something"}

object Main {
 def main(args:Array[String]) = {
    val someClassTrait:SomeTrait = Class.forName("SomeClass").newInstance().asInstanceOf[SomeTrait]
    println("calling someClassTrait: " + someClassTrait.someMethod)
    val objectName = "SomeObject$"
    val cons = Class.forName(objectName).getDeclaredConstructors(); 
    cons(0).setAccessible(true);
    val someObjectTrait:SomeTrait = cons(0).newInstance().asInstanceOf[SomeTrait]
    println("calling someObjectTrait: " + someObjectTrait.someMethod)
  }
}

//prints:
calling someClassTrait: something
calling someObjectTrait: something

I think it does break the expectation of clients of a companion (singleton) object if you create new instances of it. — Thomas Jung, Jun 15 '10 at 07:36
Arjan - thanks. That's exactly what I was looking for. Thomas - That's true. But you could always wrap the code in an object factory and provide the singleton behavior yourself. — sanjib, Jun 15 '10 at 17:10

How do I call a Scala Object method using reflection?

3 Answers3

Linked

Related