[Performance] Add Reflection Cache for Performance Improvement

[CrazyHZM]

中文描述

背景

代码分析发现 SOFABoot 中多处使用反射（Class.forName、Method.invoke），反射调用性能较差，且不能 JIT 内联优化。当前缺少反射结果缓存机制，导致重复反射调用。

发现的反射调用点

sofa-boot-project/sofa-boot-actuator/health/HealthIndicatorProcessor.java:136
- Class.forName(exclude)

sofa-boot-project/sofa-boot-core/rpc-sofa-boot/RpcBindingConverter.java
- sofaMethod.invokeType()

sofa-boot-project/sofa-boot-core/tracer-sofa-boot/DataSourceBeanPostProcessor.java
- urlMethod.invoke(bean)

sofa-boot-project/sofa-boot/annotation/AnnotationWrapper.java
- Proxy.newProxyInstance()

建议实现方案

1. 统一反射缓存管理器

@Component
public class ReflectionCache {

    // Class 缓存
    private final ConcurrentHashMap<String, Class<?>> classCache = new ConcurrentHashMap<>();

    // Method 缓存
    private final ConcurrentHashMap<MethodKey, Method> methodCache = new ConcurrentHashMap<>();

    // Constructor 缓存
    private final ConcurrentHashMap<ConstructorKey, Constructor<?>> constructorCache =
        new ConcurrentHashMap<>();

    // 统计信息
    private final AtomicLong hitCount = new AtomicLong(0);
    private final AtomicLong missCount = new AtomicLong(0);

    public Class<?> forName(String className) throws ClassNotFoundException {
        Class<?> clazz = classCache.get(className);
        if (clazz != null) {
            hitCount.incrementAndGet();
            return clazz;
        }

        missCount.incrementAndGet();
        try {
            clazz = Class.forName(className);
            classCache.put(className, clazz);
            return clazz;
        } catch (ClassNotFoundException e) {
            // 缓存 null 避免重复加载失败的类
            classCache.put(className, null);
            throw e;
        }
    }

    public Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
            throws NoSuchMethodException {
        MethodKey key = new MethodKey(clazz, methodName, paramTypes);

        Method method = methodCache.get(key);
        if (method != null) {
            hitCount.incrementAndGet();
            return method;
        }

        missCount.incrementAndGet();
        method = clazz.getMethod(methodName, paramTypes);
        method.setAccessible(true);  // 优化访问权限检查
        methodCache.put(key, method);
        return method;
    }

    public Constructor<?> getConstructor(Class<?> clazz, Class<?>... paramTypes)
            throws NoSuchMethodException {
        ConstructorKey key = new ConstructorKey(clazz, paramTypes);

        Constructor<?> constructor = constructorCache.get(key);
        if (constructor != null) {
            hitCount.incrementAndGet();
            return constructor;
        }

        missCount.incrementAndGet();
        constructor = clazz.getConstructor(paramTypes);
        constructor.setAccessible(true);
        constructorCache.put(key, constructor);
        return constructor;
    }

    public CacheStats getStats() {
        long hits = hitCount.get();
        long misses = missCount.get();
        long total = hits + misses;
        double hitRate = total == 0 ? 0 : (double) hits / total;

        return new CacheStats(hits, misses, hitRate,
            classCache.size(), methodCache.size(), constructorCache.size());
    }

    @Data
    @AllArgsConstructor
    public static class CacheStats {
        private long hits;
        private long misses;
        private double hitRate;
        private int classCacheSize;
        private int methodCacheSize;
        private int constructorCacheSize;
    }

    @Value
    private static class MethodKey {
        Class<?> clazz;
        String methodName;
        Class<?>[] paramTypes;
    }
}

2. 使用 MethodHandle (Java 7+)

对于 HotSpot JVM，可以提供 MethodHandle 优化版本：

@Component
public class MethodHandleCache {

    private static final MethodHandles.Lookup lookup = MethodHandles.publicLookup();

    private final ConcurrentHashMap<MethodKey, MethodHandle> handleCache =
        new ConcurrentHashMap<>();

    public MethodHandle getMethodHandle(Method method) throws IllegalAccessException {
        MethodKey key = new MethodKey(
            method.getDeclaringClass(),
            method.getName(),
            method.getParameterTypes()
        );

        return handleCache.computeIfAbsent(key, k -> {
            try {
                return lookup.unreflect(method);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        });
    }

    public Object invoke(Method method, Object target, Object... args) throws Throwable {
        MethodHandle handle = getMethodHandle(method);
        return handle.invokeWithArguments(args);
    }
}

3. 应用到现有代码

优化 HealthIndicatorProcessor:

// 优化前
for (String exclude : excludes) {
    try {
        Class<?> c = Class.forName(exclude);  // 每次都重新加载
        excludedIndicators.add(c);
    } catch (Throwable e) {
        logger.warn("Unable to find excluded HealthIndicator class {}", exclude);
    }
}

// 优化后
@Autowired
private ReflectionCache reflectionCache;

for (String exclude : excludes) {
    try {
        Class<?> c = reflectionCache.forName(exclude);  // 从缓存获取
        if (c != null) {
            excludedIndicators.add(c);
        }
    } catch (ClassNotFoundException e) {
        logger.warn("Unable to find excluded HealthIndicator class {}", exclude);
    }
}

优化 DataSourceBeanPostProcessor:

// 优化前
Method urlMethod = dataSource.getClass().getMethod("getUrl");
url = (String) urlMethod.invoke(bean);

// 优化后
Method urlMethod = reflectionCache.getMethod(dataSource.getClass(), "getUrl");
url = (String) reflectionCache.invoke(urlMethod, bean);

4. 监控端点

@Endpoint(id = "reflection-cache")
public class ReflectionCacheEndpoint {

    @Autowired
    private ReflectionCache reflectionCache;

    @ReadOperation
    public ReflectionCache.CacheStats stats() {
        return reflectionCache.getStats();
    }

    @WriteOperation
    public void clear() {
        reflectionCache.clear();
    }
}

预期性能提升

操作	优化前	优化后	提升
Class.forName	50-100μs	~1μs	50-100x
Method.invoke	15-20ns	5-10ns	2-4x
内存占用	每次新建	复用缓存	减少 GC

兼容性

• 完全向后兼容
• 可选开关：sofa.boot.reflection.cache.enabled=true
• 支持 JDK 8+

---

Description (English)

Background

Code analysis found multiple uses of reflection in SOFABoot (Class.forName, Method.invoke). Reflection calls have poor performance and cannot be JIT-inlined. Currently, there is no reflection result caching mechanism, leading to repeated reflection calls.

Reflection Call Points Found

HealthIndicatorProcessor.java:136 - Class.forName(exclude)
RpcBindingConverter.java - sofaMethod.invokeType()
DataSourceBeanPostProcessor.java - urlMethod.invoke(bean)
AnnotationWrapper.java - Proxy.newProxyInstance()

Suggested Implementation

1. Unified Reflection Cache Manager

@Component
public class ReflectionCache {

    private final ConcurrentHashMap<String, Class<?>> classCache = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<MethodKey, Method> methodCache = new ConcurrentHashMap<>();

    public Class<?> forName(String className) throws ClassNotFoundException {
        Class<?> clazz = classCache.get(className);
        if (clazz != null) return clazz;

        clazz = Class.forName(className);
        classCache.put(className, clazz);
        return clazz;
    }

    public Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
            throws NoSuchMethodException {
        MethodKey key = new MethodKey(clazz, methodName, paramTypes);

        Method method = methodCache.get(key);
        if (method != null) return method;

        method = clazz.getMethod(methodName, paramTypes);
        method.setAccessible(true);
        methodCache.put(key, method);
        return method;
    }
}

2. Monitor Endpoint

@Endpoint(id = "reflection-cache")
public class ReflectionCacheEndpoint {

    @ReadOperation
    public ReflectionCache.CacheStats stats() {
        return reflectionCache.getStats();
    }
}

Expected Performance Improvement

Operation	Before	After	Improvement
Class.forName	50-100μs	~1μs	50-100x
Method.invoke	15-20ns	5-10ns	2-4x

/label ~enhancement ~performance ~optimization