Spring CgLib Dynamic AOP Proxies - proper Pointcut equals method is simply essential

public Object getProxiedVersion(Object original) {
    //will create proxy factory based on original object
    ProxyFactory proxyFactory = new ProxyFactory(original);
    //this will add our result caching advisor
    proxyFactory.addAdvisor(
       new DefaultPointcutAdvisor(
          new DataProviderPointcut(),
          new ResultCachingAdvice()
       )
    );
    //this will cause CgLib will be used to generate proxy class
    //and not JDK proxy proxying only interfaces that orignal object implements
    proxyFactory.setProxyTargetClass(true);
    //this is only optimalization thing - means we won't touch advisors
    //after proxy has been created - so Spring could optimalize calls
    proxyFactory.setFrozen(true);
    //this will create dynamic class and instance of it
    return proxyFactory.getProxy();
}

public void testDynamicClassGarbageCollection() {
    //create proxy factory
    ProxyFactory proxyFactory = new ProxyFactory(new Object());
    proxyFactory.setProxyTargetClass(true);
    //we'll force proxy factory to use our own classloader
    //with defining standard classloader as a parent of it
    ClassLoader clsLdr = new ClassLoader(
            Thread.currentThread().getContextClassLoader()
    ) {};
    //create proxy class and intance and keep weak references
    //to them
    WeakReference proxyRef = new WeakReference(
            proxyFactory.getProxy(clsLdr)
    );
    WeakReference proxyClassRef = new WeakReference(
            proxyRef.get().getClass()
    );
    //this should destroy all non referenced instances
    //we have no reference either to proxy or proxy class
    //(WeakReferences don't count)
    System.gc();
    //proxy instance gets garbage collected
    assertNull(proxyRef.get());
    //but class does not!
    assertNotNull(proxyClassRef.get());
    //we have dispose class loader in order to dispose generated
    //proxy class
    clsLdr = null;
    System.gc();
    assertNull(proxyClassRef.get());
}

public void testGetProxiedVersion() {
    long iteration = 0;
    Lookup tested = new Lookup();
    do {
        tested.getProxiedVersion(new Object());
        iteration++;
        if (iteration % 100 == 0) {
            System.out.println("Successfuly proxied: " + iteration + " objects");
        }
    } while (true);
}

//this will add our result caching advisor
proxyFactory.addAdvisor(
   new DefaultPointcutAdvisor(
      new DataProviderPointcut(),
      new ResultCachingAdvice()
   )
);

public class DataProviderPointcut implements Pointcut {
    public ClassFilter getClassFilter() {
        return new RootClassFilter(DataProvider.class);
    }
    public MethodMatcher getMethodMatcher() {
        return MethodMatcher.TRUE;
    }
}

private Object createHelper() {
	validate();
	if (superclass != null) {
		setNamePrefix(superclass.getName());
	} else if (interfaces != null) {
		setNamePrefix(interfaces[ReflectUtils.findPackageProtected(interfaces)].getName());
	}
	return super.create(KEY_FACTORY.newInstance((superclass != null) ?
           superclass.getName() : null,
           ReflectUtils.getNames(interfaces),
           filter,
           callbackTypes,
           useFactory,
           interceptDuringConstruction,
           serialVersionUID)
       );
}

public boolean equals(Object other) {
	if (other == this) {
		return true;
	}
	if (!(other instanceof ProxyCallbackFilter)) {
		return false;
	}
	ProxyCallbackFilter otherCallbackFilter = (ProxyCallbackFilter) other;
	AdvisedSupport otherAdvised = otherCallbackFilter.advised;
	if (this.advised == null || otherAdvised == null) {
		return false;
	}
	if (this.advised.isFrozen() != otherAdvised.isFrozen()) {
		return false;
	}
	if (this.advised.isExposeProxy() != otherAdvised.isExposeProxy()) {
		return false;
	}
	if (this.advised.getTargetSource().isStatic() != otherAdvised.getTargetSource().isStatic()) {
		return false;
	}
	if (!AopProxyUtils.equalsProxiedInterfaces(this.advised, otherAdvised)) {
		return false;
	}
	// Advice instance identity is unimportant to the proxy class:
	// All that matters is type and ordering.
	Advisor[] thisAdvisors = this.advised.getAdvisors();
	Advisor[] thatAdvisors = otherAdvised.getAdvisors();
	if (thisAdvisors.length != thatAdvisors.length) {
		return false;
	}
	for (int i = 0; i < thisAdvisors.length; i++) {
		Advisor thisAdvisor = thisAdvisors[i];
		Advisor thatAdvisor = thatAdvisors[i];
		if (!equalsAdviceClasses(thisAdvisor, thatAdvisor)) {
			return false;
		}
		if (!equalsPointcuts(thisAdvisor, thatAdvisor)) {
			return false;
		}
	}
	return true;
}
private boolean equalsAdviceClasses(Advisor a, Advisor b) {
	Advice aa = a.getAdvice();
	Advice ba = b.getAdvice();
	if (aa == null || ba == null) {
		return (aa == ba);
	}
	return aa.getClass().equals(ba.getClass());
}
private boolean equalsPointcuts(Advisor a, Advisor b) {
	// If only one of the advisor (but not both) is PointcutAdvisor, then it is a mismatch.
	// Takes care of the situations where an IntroductionAdvisor is used (see SPR-3959).
	if (a instanceof PointcutAdvisor ^ b instanceof PointcutAdvisor) {
		return false;
	}
	// If both are PointcutAdvisor, match their pointcuts.
	if (a instanceof PointcutAdvisor && b instanceof PointcutAdvisor) {
		return ObjectUtils.nullSafeEquals(((PointcutAdvisor) a).getPointcut(), ((PointcutAdvisor) b).getPointcut());
	}
	// If neither is PointcutAdvisor, then from the pointcut matching perspective, it is a match.
	return true;
}