Can you force a java object into implementing an interface at runtime?

You can't make the object itself implement the interface, but you could use something like Proxy to create an object which implements the interface and uses reflection to call the appropriate member on the original object.

Of course, if it's just the one interface type and the one concrete type, you could easily write such a wrapper without using Proxy:

public class BarWrapper implements Foo
{
    private final Bar bar;

    public BarWrapper(Bar bar)
    {
        this.bar = bar;
    }

    public int someMethodInFoo()
    {
        return bar.someMethodInFoo();
    }

    // etc
}

This should be solvable with an adapter. Have an other class defined that implements your interface and delegates to the real object:

class YourAdapter implements YourInterface {

    private final YourClass realObject;

    public YourAdapter(YourClass realObject) {
        this.realObject = realObject;
    }

    @Override
    public methodFromInterface() {
        // you said the class has the same method signatures although it doesn't
        // implement the interface, so this should work fine:
        realObject.methodFromInterface();
    }

    // .......

}

Now, given a method that expects YourInterface and an object of type YourClass:

void someMethod(YourInterface param) {}

void test() {
    YourClass object = getFromSomewhere();
    someMethod( YourAdapter(object) );
}

You can probably do what you want with Javassist, either by modifying the class's bytecode or creating a wrapper/proxy class.

Basically there are two ways:

a) write a decorator around your Object that implements the interface and delegates to your object (this can be done either by using proxies or by writing a simple adapter class)

b) change the byte code. Spring AOP is not powerful enough to do that, but the AspectJ compiler is. It's a one-liner:

declare parents: YourClass implements YourInterface;

Since you don't have access to the class source you will have to either use Load Time Weaving or weave the library jar. All of this is explained well in AspectJ in Action by Ramnivas Laddad