How to Use Java 8 Dynamic Proxies with Default Methods

Question

What are dynamic proxies in Java 8 and how can you use them with default methods in interfaces?

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

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

public class DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface proxyInstance = (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("specificMethod")) {
                        System.out.println("Specific method invoked");
                    }
                    return null;
                }
            }
        );
        proxyInstance.defaultMethod(); // Calls the default method
        proxyInstance.specificMethod(); // Calls the specific method
    }
}

Answer

Java 8 introduced functional programming concepts and various enhancements, including the ability to create dynamic proxies that can handle interfaces with default methods. A dynamic proxy in Java is a class that implements a list of interfaces specified at runtime and forwards method calls to a specified invocation handler.

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

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

public class DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface proxyInstance = (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("specificMethod")) {
                        System.out.println("Specific method invoked");
                    }
                    return null;
                }
            }
        );
        proxyInstance.defaultMethod(); // Calls the default method
        proxyInstance.specificMethod(); // Calls the specific method
    }
}

Causes

Java 8 allows interfaces to have default methods, enabling developers to add new methods without breaking existing implementations.
Dynamic proxies enable method calls to be handled dynamically at runtime, providing great flexibility for implementing behavior that can be modified or extended without modifying the actual implementation.

Solutions

Use java.lang.reflect.Proxy to create a proxy instance of an interface that has default methods.
Implement the InvocationHandler interface to define how method calls to the proxy should be handled.

Common Mistakes

Mistake: Forgetting to implement InvocationHandler correctly, leading to NullPointerExceptions.

Solution: Ensure that all method calls are correctly forwarded through the invoke() method.

Mistake: Assuming that default methods can be overridden in the proxy.

Solution: Default methods are called directly on the interface implementation by the proxy.

Helpers

Java 8 dynamic proxies
default methods in Java
Java dynamic proxy examples
InvocationHandler in Java