Scala & the Proxy design pattern

In this article we will focus on the Proxy design pattern as defined by the GoF.
In short, the definition of the "Proxy" pattern could be reduced to "something for something". That's why it will be presented here as the Quid Pro Quo pattern, "Quo" meaning the entity that will be controlled/wrapped by the "Quid" entity (i.e. the proxy itself).

Using implicit conversions

Let's see the benefit of the Scala language features when applied to such a useful pattern...
In order to implement the Proxy pattern, here is what is needed first:

• A generic implementation of the QuidProQuo concept: a trait called QuidPro defined over the Quo type and that basically wraps a Quo instance:
  

/** * The QuidProQuo abstraction * (canonical Proxy pattern) */ trait QuidPro[Quo] { val quo : Quo }

• The "Quo" entity (i.e. the one that we would like to be controlled by a proxy). For instance, this awesome trait:
  

trait Trait1{ def invoke1(param: String):String = "Hello " + param + " !!" }

• And finally the implementation of the proxy for Trait1. Let's call it QuidProTrait1. This trait extends Trait1 (the "Quid" must override all the methods of its nested "Quo" instance). The QuidProTrait1 is a QuidPro[Trait1] as well (explicitly declares that it's a "Quid" for Trait1):

trait QuidProTrait1 extends Trait1 with QuidPro[Trait1] { override def invoke1(param: String) = this + " says: \"" +quo.invoke1(param)+"\"" } At this stage, it would be nice to get a proxy instance of a given Trait1 in a concise manner and without polluting the Trait1 and QuidProTrait1 code.
Here comes the beauty of the Scala language ... Let's use the implicit conversion feature:
// Generic Proxy creator (works together with the QuidPro[Quo] trait) implicit def toProxy[Quo](q :Quo) = new { def createProxy:QuidPro[Quo] = new {val quo = q} with QuidPro[Quo] } This code allows to automatically add a createProxy method to any trait or class. It applies an implicit conversion to a QuidPro[Quo] instance (as soon as the compiler meets a createProxy invocation on a Quo instance).
Note that the scope of the createProxy method can be reduced by changing the type of the toProxy implicit definition (e.g. toProxy[Quo <: AcceptProxy] where AcceptProxy is some marker trait).
By the way, this technique of enriching an abstraction without specifying extensions (using inheritance) corresponds to the Decorator design pattern. We have to admit that the Scala answer to this pattern is unique and quite efficient.

In order to get the whole picture, we need to see the implicitly generated instance of QuidPro[Trait1] as a QuidProTrait1 instance. This can be achieved using an additional implicit conversion: implicit def quidProQuo(x : QuidPro[Trait1]): QuidProTrait1 = new QuidProTrait1 { override val quo : Trait1 = x.quo } Then, the following code: object p extends Trait1 println(p.invoke1("World")) val q = p.asInstanceOf[Trait1].createProxy println(q.invoke1("World")) println(q.isInstanceOf[Trait1]) will output this:

Note that we can also parametrize the Quid, by using the implicit parameter feature. That's what is done in the following implementation of Trait2 (which does the same as Trait1 but manages an additional "creator name" field.
Here is the complete example: package scaladudes object ProxyTestApp extends Application { /** * The QuidProQuo abstraction * (canonical Proxy pattern) */ trait QuidPro[Quo] { val quo : Quo } // Generic Proxy creator (works together with the QuidPro[Quo] trait) implicit def toProxy[Quo](q :Quo) = new { def createProxy:QuidPro[Quo] = new {val quo = q} with QuidPro[Quo] } /******************* Trait1 Specific code ****************/ trait Trait1{ def invoke1(param: String):String = "Hello " + param + " !!" } trait QuidProTrait1 extends Trait1 with QuidPro[Trait1] { override def invoke1(param: String) = this + " says: \"" +quo.invoke1(param)+"\"" } implicit def quidProQuo(x : QuidPro[Trait1]): QuidProTrait1 = new QuidProTrait1 { override val quo : Trait1 = x.quo } /******************* Trait2 Specific code ****************/ trait Trait2{ def invoke2(param: String):String = "Hi " + param + " !!" } trait QuidProTrait2 extends Trait2 with QuidPro[Trait2] { val creatorName : String override def invoke2(param: String) = this + " says: \"" +quo.invoke2(param) + "\" (created by " + creatorName + ")" } implicit def quidProQuo(x : QuidPro[Trait2])(implicit str:String): QuidProTrait2 = new QuidProTrait2 { override val creatorName = str override val quo : Trait2 = x.quo } /**********************************************/ implicit val myName = "a dude" class MyClass extends Trait1 with Trait2 val q = new MyClass println(q.invoke1("World")) println(q.invoke2("Everybody")) val q1 : Trait1 = r.asInstanceOf[Trait1].createProxy val q2 : Trait2 = r.asInstanceOf[Trait2].createProxy println(s.invoke1("World")) println(t.invoke2("Everybody")) } You should obtain something like this:

Alternative: back to Java Proxy

Relying on the Scala's interoperability with Java, we can use the Java Proxy (from package java.lang.reflect). This is the purpose of the following code snippet:
package scaladudes import java.lang.reflect.{InvocationHandler, Method, Proxy} /** * A Scalafied version of the java.lang.reflect.InvocationHandler */ trait ScalaInvocationHandler[T] { def invoke(proxy: T, method : Method, args: Array[AnyRef]) : AnyRef } /** * The Scala Proxy component */ object scalaProxy { /** * Returns a Quid (i.e. a Proxy) for a given class type T. * Note that the first parameter (klass) is redundant but cannot be */ def getQuid[T](klass: Class[_], handler:ScalaInvocationHandler[T]):T = { // creates a new Java invocation handler that transfers any invocation // to the passed in ScalaInvocationHandler parameter val invocationHandler = new InvocationHandler() { def invoke(proxy: AnyRef, method : Method, args: Array[Object]) : Object = { handler.invoke(proxy.asInstanceOf[T], method, args.asInstanceOf[Array[AnyRef]]); } } // returns a Java Proxy as an instance of T return Proxy.newProxyInstance(klass.getClassLoader, Array(klass), invocationHandler).asInstanceOf[T]; } } /************************** Example ***********************************/ trait SpeakingTrait { def sayHello(to:String):String = "Hello " + to + " !!" def say(what:String, to:String):String = what + " " + to + " !!" } object ProxyTest extends Application { // Creates the "quo" object (the one that will have a proxy) object quo extends SpeakingTrait // Instanciates a proxy for the SpeakingTrait i.e. creates a "quid" for "quo" val quid = scalaProxy.getQuid[SpeakingTrait]( classOf[SpeakingTrait], // Could be somehow avoided ?? new ScalaInvocationHandler[SpeakingTrait] { def invoke(proxy: SpeakingTrait, method : Method, args: Array[AnyRef]) : AnyRef = { // Intercept the call println(">>> scalaInvocationHandler: method \"" + method.getName + "\" intercepted.") // And invokes "quo" "Quo says: \"" + method.invoke(quo, args: _*) + "\"" } } ) // And invokes the proxy println(quid.sayHello("Scala Dudes")); println(quid.say("Hi", "Folks")); } The execution of this example should result in the following output:

As a conclusion ...

... I'd only say that the Scala translation of the Proxy pattern is not that different from the Java one, but the implicit conversion and implicit parameter features make it a bit more elegant...