Defensively handle fast class generation failure for individual methods

Includes rethrowing of last actual defineClass exception encountered.

Closes gh-27490

spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2020 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -237,7 +237,7 @@ class CglibAopProxy implements AopProxy, Serializable {
 	 * validates it if not.
 	 */
 	private void validateClassIfNecessary(Class<?> proxySuperClass, @Nullable ClassLoader proxyClassLoader) {
-		if (logger.isWarnEnabled()) {
+		if (logger.isInfoEnabled()) {
 			synchronized (validatedClasses) {
 				if (!validatedClasses.containsKey(proxySuperClass)) {
 					doValidateClass(proxySuperClass, proxyClassLoader,
@@ -679,13 +679,19 @@ class CglibAopProxy implements AopProxy, Serializable {
 				Object retVal;
 				// Check whether we only have one InvokerInterceptor: that is,
 				// no real advice, but just reflective invocation of the target.
-				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
+				if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {
 					// We can skip creating a MethodInvocation: just invoke the target directly.
 					// Note that the final invoker must be an InvokerInterceptor, so we know
 					// it does nothing but a reflective operation on the target, and no hot
 					// swapping or fancy proxying.
 					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
-					retVal = methodProxy.invoke(target, argsToUse);
+					try {
+						retVal = methodProxy.invoke(target, argsToUse);
+					}
+					catch (CodeGenerationException ex) {
+						CglibMethodInvocation.logFastClassGenerationFailure(method);
+						retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
+					}
 				}
 				else {
 					// We need to create a method invocation...
@@ -737,10 +743,7 @@ class CglibAopProxy implements AopProxy, Serializable {
 			super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);
 
 			// Only use method proxy for public methods not derived from java.lang.Object
-			this.methodProxy = (Modifier.isPublic(method.getModifiers()) &&
-					method.getDeclaringClass() != Object.class && !AopUtils.isEqualsMethod(method) &&
-					!AopUtils.isHashCodeMethod(method) && !AopUtils.isToStringMethod(method) ?
-					methodProxy : null);
+			this.methodProxy = (isMethodProxyCompatible(method) ? methodProxy : null);
 		}
 
 		@Override
@@ -776,10 +779,25 @@ class CglibAopProxy implements AopProxy, Serializable {
 		@Override
 		protected Object invokeJoinpoint() throws Throwable {
 			if (this.methodProxy != null) {
-				return this.methodProxy.invoke(this.target, this.arguments);
+				try {
+					return this.methodProxy.invoke(this.target, this.arguments);
+				}
+				catch (CodeGenerationException ex) {
+					logFastClassGenerationFailure(this.method);
+				}
 			}
-			else {
-				return super.invokeJoinpoint();
+			return super.invokeJoinpoint();
+		}
+
+		static boolean isMethodProxyCompatible(Method method) {
+			return (Modifier.isPublic(method.getModifiers()) &&
+					method.getDeclaringClass() != Object.class && !AopUtils.isEqualsMethod(method) &&
+					!AopUtils.isHashCodeMethod(method) && !AopUtils.isToStringMethod(method));
+		}
+
+		static void logFastClassGenerationFailure(Method method) {
+			if (logger.isDebugEnabled()) {
+				logger.debug("Failed to generate CGLIB fast class for method: " + method);
 			}
 		}
 	}

spring-core/src/main/java/org/springframework/cglib/core/ReflectUtils.java

@@ -499,6 +499,7 @@ public class ReflectUtils {
 			ProtectionDomain protectionDomain, Class<?> contextClass) throws Exception {
 
 		Class c = null;
+		Throwable t = THROWABLE;
 
 		// Preferred option: JDK 9+ Lookup.defineClass API if ClassLoader matches
 		if (contextClass != null && contextClass.getClassLoader() == loader &&
@@ -516,6 +517,7 @@ public class ReflectUtils {
 				// in case of plain LinkageError (class already defined)
 				// or IllegalArgumentException (class in different package):
 				// fall through to traditional ClassLoader.defineClass below
+				t = target;
 			}
 			catch (Throwable ex) {
 				throw new CodeGenerationException(ex);
@@ -543,6 +545,7 @@ public class ReflectUtils {
 				if (!ex.getClass().getName().endsWith("InaccessibleObjectException")) {
 					throw new CodeGenerationException(ex);
 				}
+				t = ex;
 			}
 		}
 
@@ -564,7 +567,7 @@ public class ReflectUtils {
 
 		// No defineClass variant available at all?
 		if (c == null) {
-			throw new CodeGenerationException(THROWABLE);
+			throw new CodeGenerationException(t);
 		}
 
 		// Force static initializers to run.