com.sun.proxy。$ Proxy219无法使用Java Config进行强制转换，但可以与xml一起正常使用

Question

I'm migrating a Couchbase cache manager configuration from our legacy xml to a Java Config.

But I'm getting a java.lang.ClassCastException: com.sun.proxy.$Proxy219 cannot be cast to atorrico.cache.CouchbaseCache.

This is the XML file

<context:annotation-config />

<cache:annotation-driven />

<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    <property name="caches">
        <set>
            <ref local="mainCache" />
        </set>
    </property>
</bean>

<bean id="mainCache" class="atorrico.cache.CouchbaseCache" destroy-method="shutdown">
    <constructor-arg index="0" value="${cache.main.name}" />
    <constructor-arg index="1" value="${cache.servers}" />
    <constructor-arg index="2" value="${cache.main.bucket.name}" />
    <constructor-arg index="3" value="${cache.main.bucket.password}" />
    <constructor-arg index="4" ref="couchbaseJaxb2Transcoder" />
    <constructor-arg index="5" value="${cache.main.ttl}" />
    <property name="operationTimeoutMillis" value="${cache.main.operationTimeoutMillis}" />
    <property name="clientResetIntervalSeconds" value="${cache.main.clientResetIntervalSeconds}" />
    <property name="enabled" value="${cache.main.enabled}" />
</bean>

<bean id="couchbaseJaxb2Transcoder" class="atorrico.couchbase.CouchbaseJaxb2Transcoder">
   <property name="marshaller" ref="cacheJaxb2Marshaller" />
</bean>

<bean id="cacheJaxb2Marshaller" class="atorrico.couchbase.TweakedJaxb2Marshaller">
    <property name="contextPath"
        value="${cache.main.contextPath}" />
</bean>

This is the Java Config file

@Configuration
@EnableCaching
@EnableMBeanExport
public class CacheConfiguration {
    @Value("${cache.main.name}")
    private String mainCacheName;

    @Value("${cache.servers}")
    private String mainCacheServers;

    @Value("${cache.main.bucket.name}")
    private String mainCacheBucketName;

    @Value("${cache.main.bucket.password}")
    private String mainCacheBucketPassword;

    @Value("${cache.main.ttl}")
    private Integer mainCacheTtl;

    @Value("${cache.main.operationTimeoutMillis}")
    private Integer mainCacheOperationTimeoutMillis;

    @Value("${cache.main.clientResetIntervalSeconds : -1}")
    private Integer mainClientResetIntervalSeconds;

    @Value("${cache.main.enabled}")
    private Boolean mainCacheEnabled;

    @Value("${cache.main.operation.queue.length : -1}")
    private Integer mainCacheOperationQueueLength;

    @Value("${cache.main.contextPath}")
    private Integer mainCacheContextPath;

    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(Arrays.asList(mainCouchbaseCache()));
        return cacheManager;
    }

    @Bean(name = "mainCache", destroyMethod = "shutdown")
    @Qualifier("mainCache")
    public CouchbaseCache mainCouchbaseCache() {
        CouchbaseCache couchbaseClient = new CouchbaseCache(mainCacheName, mainCacheServers, mainCacheBucketName, mainCacheBucketPassword,
                mainCouchbaseJaxb2Transcoder(), mainCacheTtl);

        couchbaseClient.setOperationTimeoutMillis(mainCacheOperationTimeoutMillis);
        couchbaseClient.setClientResetIntervalSeconds(mainClientResetIntervalSeconds);
        couchbaseClient.setEnabled(mainCacheEnabled);
        couchbaseClient.setOperationQueueLength(mainCacheOperationQueueLength);
        return couchbaseClient;
    }

    @Bean(name = "mainCouchbaseJaxb2Transcoder")
    public CouchbaseJaxb2Transcoder mainCouchbaseJaxb2Transcoder() {

        CouchbaseJaxb2Transcoder couchbaseJaxb2Transcoder = new CouchbaseJaxb2Transcoder();
        couchbaseJaxb2Transcoder.setMarshaller(mainJaxb2Marshaller());
        return couchbaseJaxb2Transcoder;
    }

    @Bean(name = "mainJaxb2Marshaller")
    public TweakedJaxb2Marshaller mainJaxb2Marshaller() {

        TweakedJaxb2Marshaller txStoreJaxb2Marshaller = new TweakedJaxb2Marshaller();
        txStoreJaxb2Marshaller.setContextPath(mainCacheContextPath);
        return txStoreJaxb2Marshaller;
    }

I think the only difference between both version is that in the xml I have a

<ref local="mainCache" />

Note the use of local instead bean.

This is the hierarchy of java classes for the Couchbase client.

public interface CouchbaseClient {

....

}

public interface CouchbaseClientManagement {

....

}

public class CouchbaseClientImpl implements CouchbaseClient, CouchbaseClientManagement {

.....

}

public class CouchbaseCache extends CouchbaseClientImpl implements Cache, CouchbaseClientManagement {

....

}

This is the trace

Caused by: java.lang.ClassCastException: com.sun.proxy.$Proxy219 cannot be cast to atorrico.cache.CouchbaseCache
at atorrico.cache.configuration.CacheConfiguration$$EnhancerBySpringCGLIB$$dd4e20b8.mainCouchbaseCache(<generated>)
at atorrico.cache.configuration.CacheConfiguration.cacheManager(CacheConfiguration.java:76)
at atorrico.cache.configuration.CacheConfiguration$$EnhancerBySpringCGLIB$$dd4e20b8.CGLIB$cacheManager$0(<generated>)
at atorrico.cache.configuration.CacheConfiguration$$EnhancerBySpringCGLIB$$dd4e20b8$$FastClassBySpringCGLIB$$a8a6f2da.invoke(<generated>)
at org.springframework.cglib.proxy.MethodProxy.invokeSuper(MethodProxy.java:228)
at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.intercept(ConfigurationClassEnhancer.java:309)
at atorrico.cache.configuration.CacheConfiguration$$EnhancerBySpringCGLIB$$dd4e20b8.cacheManager(<generated>)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:162)
... 67 more

Why is this failing with Java Config but working fine with the XML config?

Can anyone find out what's going on here?

Thanks!

Answer 1

Spring has enhanced your CacheConfiguration class with some extra byte code. It's probably done this by creating a proxy that is a subclass of CacheConfiguration. You can see this in your stack trace as the class CacheConfiguration$$EnhancerBySpringCGLIB$$dd4e20b8.

When Spring instantiates the CacheManager, it first calls down through the cacheManager method it generated in the subclass, then calls your original cacheManager method, which calls the mainCouchbaseCache method.

Here's where it starts to get interesting. Your cacheManager method invokes not your mainCouchbaseCache method, but rather the generated one in the subclass. The generated method calls your mainCouchbaseCache, and your method generates the CouchbaseCache object and returns it. After your method returns, control returns to the generated subclass, which then wraps the returned CouchbaseCache in a generated proxy .

I'm not sure why Spring is generating the proxy, but for some reason it's decided that it needs to intercept calls to the methods of CouchbaseCache.

The problem is that because CouchbaseCache implements some interfaces, Spring creates a JDK dynamic proxy, and a limitation of JDK dynamic proxies is that they can only implement interfaces, not extend classes. (They extend java.lang.reflect.Proxy.) So the value that your cacheManager method sees returned from the mainCouchbaseCache method is not an instance of CouchbaseCache but rather an instance of some subclass of java.lang.reflect.Proxy that implements the Cache and CouchbaseClientManagement interfaces.

This works with the XML bean file because there is no Spring-generated proxy messing with the return value of the mainCouchbaseCache method.

I think you can fix this just by making mainCouchbaseCache return Cache instead of CouchbaseCache. Then at compile time Arrays.asList will expect a Cache array instead of a CouchbaseCache array, and since the returned proxy will implement Cache, everything will work.

Or you can tell Spring to not use a JDK dynamic proxy; see the Spring documentation on how it generates proxies . I think you want to use proxy-target-class=true, which will tell Spring to use CGLIB to generate an actual subclass CouchbaseCache.