Creating anonymous classes from Java interfaces in JRuby

Today I tried to create an anonymous class from an inteface in JRuby. After a little bit of experimenting a collegue showed me that I need to alter the singelton class of an instance of the interface in order to implement a method. Here I implement the Callable-Interface:

callable = Java::java.util.concurrent.Callable.new 
class << callable
  def call
    # implements method 'call' of the Callable-Interface
  end
end

So I tried this:

require 'java'
include_class 'java.util.concurrent.Callable'
include_class 'java.util.concurrent.Executors'

msg = "from thread"

callable = Java::java.util.concurrent.Callable.new 
class << callable
  def call
    msg
  end
end

executor_service = Executors.newFixedThreadPool 1
future = executor_service.submit callable
puts "hello #{future.get}"
# -> undefined local variable or method `msg'

For my suprise, a variable defined in the outer context was invisible for the implemented method. I expected that it would behave just like a Ruby block or a Java anonymous class which can "see" the outer defined variables.

We found a workaround for this problem by calling a method on the instance that initializes a instance variable with the needed object:

require 'java'
include_class 'java.util.concurrent.Callable'
include_class 'java.util.concurrent.Executors'

msg = "from thread"

callable = Java::java.util.concurrent.Callable.new 
class << callable
  def init(msg)
    @msg = msg
  end
  def call
    @msg
  end
end
callable.init msg

executor_service = Executors.newFixedThreadPool 1
future = executor_service.submit callable
puts "hello #{future.get}"
# -> hello from thread

Please let me know if there a more elegant way to accomplish this!

Pattern to low couple to proprietary frameworks

Most Java programmers that are using proprietary libraries or other immutable frameworks are faced with a problem: Every time you need some functionality to work with a framework class you build procedural or even worse redundant code. This leads to high coupling between the framework and the rest of the application.

Here are some thoughts to solve this problem:

Inheritance
The additional functionality is added to an inherited class. This often leads to many casts and instanceof in the source code.

Simple Wrapper
A class that holds the class of the framework. All additonal functionality is added by the wrapper class. Whenever the framework class is needed it can be retrieved by a getter of the wrapper class.

Decorator
Using the decorator pattern often is not possible. The reason is that the framework class has to implement a shared interface with the decorater class but there is no way to change the framework. If the framework class does not implement such an interface the decorator pattern can not be used.

Monkey Patching
For Java-Programmers this is unusual, but often used in ruby and other dynamic languages. With the rise of JRuby and Groovy you can now patch your Java framework classes easily and follow TDA to get DRY code. In some static languages like Scala this is possible, too (see Pimp my Library).
In my opinion monkey patching is the best way to work with unchangable frameworks.