How to Explicitly Invoke a Default Method from a Dynamic Proxy in Java?

Question

How can I explicitly invoke a default method from a dynamic proxy in Java?

public interface MyInterface {
    default void defaultMethod() {
        System.out.println("Default Method");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class[] { MyInterface.class },
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if (method.getName().equals("defaultMethod")) {
                        // Invoke the default method explicitly
                        return MyInterface.super.defaultMethod();
                    }
                    return null;
                }
            });
        proxy.defaultMethod(); // Calls the proxy, which triggers the defaultMethod
    }
}

Answer

In Java, you can use dynamic proxies to create instances of interfaces at runtime. This is particularly useful when you want to add behavior or intercept method calls. However, invoking default methods defined in interfaces through proxies can be tricky. Here, we will explore how to do this correctly and effectively.

public interface MyInterface {
    default void defaultMethod() {
        System.out.println("Default Method");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class[] { MyInterface.class },
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if (method.getName().equals("defaultMethod")) {
                        // Invoke the default method explicitly
                        return MyInterface.super.defaultMethod();
                    }
                    return null;
                }
            });
        proxy.defaultMethod(); // Calls the proxy, which triggers the defaultMethod
    }
}

Causes

Lack of understanding of how dynamic proxies work with interfaces.
Confusion on how default methods are treated in terms of proxy invocations.

Solutions

Implement handling in the invoke method of the InvocationHandler to check for the default method's name.
Use MyInterface.super.defaultMethod() to invoke the default method.

Common Mistakes

Mistake: Not implementing default method invocation properly in the InvocationHandler.

Solution: Ensure you check the method name and call MyInterface.super.defaultMethod() for default methods.

Mistake: Using Instance instead of Interface type for proxy object

Solution: Always cast the proxy object to the interface it implements to avoid ClassCastException.

Helpers

Java dynamic proxy
invoke default method
Java Reflection
InvocationHandler
default methods in interface