EasyMock Platform Overview and JSF Mock Implementation Guide

The EasyMock platform, launched in 2021, offers a comprehensive mock service for group products, R&D, and testing teams, supporting JSF and HTTP interfaces across test and production environments, with over 2,000 users and more than 10 million monthly mock calls.

It addresses four main problems: unavailable dependent services, complex or exceptional data scenarios, frequent data changes, and tight testing schedules, thereby improving development speed and test reliability.

JSF Mock implementation follows a multi‑stage process: the platform downloads required JARs based on Maven coordinates, loads them into the JVM via URLClassLoader , instantiates interfaces using Java dynamic proxies, registers the mock interfaces with the JSF registry, and finally serves client requests by matching parameters and returning mock responses.

Jar download : When a user adds a JSF interface, the backend generates a POM file from the provided coordinates and asynchronously executes mvn clean dependency:copy-dependencies to fetch all dependent JARs, storing them on an NFS server.

JVM loading :

// Obtain the system class loader
URLClassLoader urlClassLoaderForJvm = (URLClassLoader) ClassLoader.getSystemClassLoader();
Class<URLClassLoader> urlClass = URLClassLoader.class;
Method method = urlClass.getDeclaredMethod("addURL", new Class[]{URL.class});
method.setAccessible(true);
for (File file : files) {
    logger.info("Dynamically loading jar: {}", file.getAbsolutePath());
    URL url = new URL("file:" + file);
    method.invoke(urlClassLoaderForJvm, new Object[]{url});
}
try {
    cls = urlClassLoaderForJvm.loadClass(interfaceName);
} catch (Exception e) {
    logger.error("Failed to load class: " + e);
}

Dynamic proxy creation uses InvocationHandler and Proxy to generate mock instances:

/**
 * JDK dynamic proxy class
 */
@Service
public class FacadeProxy implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        // mock handling
        String response = matchParams(methodId, args, method);
        return new Gson().fromJson(response, method.getReturnType());
    }
    public static
T newMapperProxy(Class
mapperInterface) throws Throwable {
        ClassLoader classLoader = mapperInterface.getClassLoader();
        Class
[] interfaces = new Class[]{mapperInterface};
        FacadeProxy proxy = new FacadeProxy();
        return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
    }
}

The platform then registers the mock interface with the JSF registry; clients invoke the mock via its alias, and the mock service matches incoming parameters using a prioritized strategy: object matching, full/partial string matching, regex matching, and finally a default wildcard.

When a match is found, the configured response template is deserialized (using FastJSON, Gson, or manual class mapping) into the expected return type, supporting primitive types, strings, simple objects, generic and complex objects.

In summary, EasyMock provides a flexible, multi‑protocol mock solution with extensive parameter templating, open API integration, performance testing support, and ongoing feature iteration, making it a valuable tool for backend developers seeking reliable service virtualization.