bugfix:fix wrong proxy of datasource bean (apache#2323)

script/client/spring/application.properties

@@ -15,6 +15,7 @@
 #
 
 seata.enabled=true
+seata.excludes-for-auto-proxying=firstClassNameForExclude,secondClassNameForExclude
 seata.application-id=applicationName
 seata.tx-service-group=my_test_tx_group
 seata.enable-auto-data-source-proxy=true

script/client/spring/application.yml

@@ -4,6 +4,7 @@ seata:
   tx-service-group: my_test_tx_group
   enable-auto-data-source-proxy: true
   use-jdk-proxy: false
+  excludes-for-auto-proxying: firstClassNameForExclude,secondClassNameForExclude
   client:
     rm:
       async-commit-buffer-limit: 1000
@@ -101,4 +102,4 @@ seata:
       session-timeout: 6000
       connect-timeout: 2000
       username: ""
-      password: ""
+      password: ""

seata-spring-boot-starter/src/main/java/io/seata/spring/boot/autoconfigure/SeataAutoConfiguration.java

@@ -16,7 +16,7 @@
 package io.seata.spring.boot.autoconfigure;
 
 import io.seata.spring.annotation.GlobalTransactionScanner;
-import io.seata.spring.annotation.datasource.SeataDataSourceBeanPostProcessor;
+import io.seata.spring.annotation.datasource.SeataAutoDataSourceProxyCreator;
 import io.seata.spring.boot.autoconfigure.properties.SeataProperties;
 import io.seata.spring.boot.autoconfigure.provider.SpringApplicationContextProvider;
 import org.slf4j.Logger;
@@ -30,7 +30,7 @@
 import org.springframework.context.annotation.DependsOn;
 
 import static io.seata.common.Constants.BEAN_NAME_SPRING_APPLICATION_CONTEXT_PROVIDER;
-import static io.seata.spring.annotation.datasource.AutoDataSourceProxyRegistrar.BEAN_NAME_SEATA_DATA_SOURCE_BEAN_POST_PROCESSOR;
+import static io.seata.spring.annotation.datasource.AutoDataSourceProxyRegistrar.BEAN_NAME_SEATA_AUTO_DATA_SOURCE_PROXY_CREATOR;
 
 /**
  * @author [email protected]
@@ -58,10 +58,10 @@ public GlobalTransactionScanner globalTransactionScanner(SeataProperties seataPr
         return new GlobalTransactionScanner(seataProperties.getApplicationId(), seataProperties.getTxServiceGroup());
     }
 
-    @Bean(BEAN_NAME_SEATA_DATA_SOURCE_BEAN_POST_PROCESSOR)
+    @Bean(BEAN_NAME_SEATA_AUTO_DATA_SOURCE_PROXY_CREATOR)
     @ConditionalOnProperty(prefix = StarterConstants.SEATA_PREFIX, name = {"enableAutoDataSourceProxy", "enable-auto-data-source-proxy"}, havingValue = "true", matchIfMissing = true)
-    @ConditionalOnMissingBean(SeataDataSourceBeanPostProcessor.class)
-    public SeataDataSourceBeanPostProcessor seataDataSourceBeanPostProcessor(SeataProperties seataProperties) {
-        return new SeataDataSourceBeanPostProcessor(seataProperties.isUseJdkProxy());
+    @ConditionalOnMissingBean(SeataAutoDataSourceProxyCreator.class)
+    public SeataAutoDataSourceProxyCreator seataAutoDataSourceProxyCreator(SeataProperties seataProperties) {
+        return new SeataAutoDataSourceProxyCreator(seataProperties.isUseJdkProxy(),seataProperties.getExcludesForAutoProxying());
     }
 }

seata-spring-boot-starter/src/main/java/io/seata/spring/boot/autoconfigure/properties/SeataProperties.java

@@ -47,6 +47,10 @@ public class SeataProperties {
      * Whether use JDK proxy instead of CGLIB proxy
      */
     private boolean useJdkProxy = false;
+    /**
+     * Specifies which datasource bean are not eligible for auto-proxying
+     */
+    private String[] excludesForAutoProxying = {};
 
     @Autowired
     private SpringCloudAlibabaConfiguration springCloudAlibabaConfiguration;
@@ -101,4 +105,13 @@ public SeataProperties setUseJdkProxy(boolean useJdkProxy) {
         this.useJdkProxy = useJdkProxy;
         return this;
     }
+
+    public String[] getExcludesForAutoProxying() {
+        return excludesForAutoProxying;
+    }
+
+    public SeataProperties setExcludesForAutoProxying(String[] excludesForAutoProxying) {
+        this.excludesForAutoProxying = excludesForAutoProxying;
+        return this;
+    }
 }

spring/src/main/java/io/seata/spring/annotation/datasource/AutoDataSourceProxyRegistrar.java

@@ -27,16 +27,20 @@
  */
 public class AutoDataSourceProxyRegistrar implements ImportBeanDefinitionRegistrar {
     private static final String ATTRIBUTE_KEY_USE_JDK_PROXY = "useJdkProxy";
-    public static final String BEAN_NAME_SEATA_DATA_SOURCE_BEAN_POST_PROCESSOR = "seataDataSourceBeanPostProcessor";
+    private static final String ATTRIBUTE_KEY_EXCLUDES = "excludes";
+    public static final String BEAN_NAME_SEATA_AUTO_DATA_SOURCE_PROXY_CREATOR = "seataAutoDataSourceProxyCreator";
 
     @Override
     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
-        if (!registry.containsBeanDefinition(BEAN_NAME_SEATA_DATA_SOURCE_BEAN_POST_PROCESSOR)) {
-            boolean useJdkProxy = Boolean.valueOf(importingClassMetadata.getAnnotationAttributes(EnableAutoDataSourceProxy.class.getName()).get(ATTRIBUTE_KEY_USE_JDK_PROXY).toString());
+        if (!registry.containsBeanDefinition(BEAN_NAME_SEATA_AUTO_DATA_SOURCE_PROXY_CREATOR)) {
+            boolean useJdkProxy = Boolean.parseBoolean(importingClassMetadata.getAnnotationAttributes(EnableAutoDataSourceProxy.class.getName()).get(ATTRIBUTE_KEY_USE_JDK_PROXY).toString());
+            String[] excludes = (String[]) importingClassMetadata.getAnnotationAttributes(EnableAutoDataSourceProxy.class.getName()).get(ATTRIBUTE_KEY_EXCLUDES);
             AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder
-                .genericBeanDefinition(SeataDataSourceBeanPostProcessor.class)
-                .addConstructorArgValue(useJdkProxy).getBeanDefinition();
-            registry.registerBeanDefinition(BEAN_NAME_SEATA_DATA_SOURCE_BEAN_POST_PROCESSOR, beanDefinition);
+                .genericBeanDefinition(SeataAutoDataSourceProxyCreator.class)
+                .addConstructorArgValue(useJdkProxy)
+                .addConstructorArgValue(excludes)
+                .getBeanDefinition();
+            registry.registerBeanDefinition(BEAN_NAME_SEATA_AUTO_DATA_SOURCE_PROXY_CREATOR, beanDefinition);
         }
     }
 

spring/src/main/java/io/seata/spring/annotation/datasource/EnableAutoDataSourceProxy.java

@@ -38,4 +38,11 @@
      * @return useJdkProxy
      */
     boolean useJdkProxy() default false;
+
+    /**
+     * Specifies which datasource bean are not eligible for auto-proxying
+     *
+     * @return
+     */
+    String[] excludes() default {};
 }

spring/src/main/java/io/seata/spring/annotation/datasource/SeataAutoDataSourceProxyAdvice.java

@@ -0,0 +1,50 @@
+/*
+ *  Copyright 1999-2019 Seata.io Group.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.seata.spring.annotation.datasource;
+
+import javax.sql.DataSource;
+import java.lang.reflect.Method;
+
+import io.seata.rm.datasource.DataSourceProxy;
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.springframework.aop.IntroductionInfo;
+import org.springframework.beans.BeanUtils;
+
+/**
+ * @author [email protected]
+ */
+public class SeataAutoDataSourceProxyAdvice implements MethodInterceptor, IntroductionInfo {
+
+    @Override
+    public Object invoke(MethodInvocation invocation) throws Throwable {
+        DataSourceProxy dataSourceProxy = DataSourceProxyHolder.get().putDataSource((DataSource) invocation.getThis());
+        Method method = invocation.getMethod();
+        Object[] args = invocation.getArguments();
+        Method m = BeanUtils.findDeclaredMethod(DataSourceProxy.class, method.getName(), method.getParameterTypes());
+        if (null != m) {
+            return m.invoke(dataSourceProxy, args);
+        } else {
+            return invocation.proceed();
+        }
+    }
+
+    @Override
+    public Class<?>[] getInterfaces() {
+        return new Class[]{SeataProxy.class};
+    }
+
+}

spring/src/main/java/io/seata/spring/annotation/datasource/SeataAutoDataSourceProxyCreator.java

@@ -0,0 +1,56 @@
+/*
+ *  Copyright 1999-2019 Seata.io Group.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.seata.spring.annotation.datasource;
+
+import javax.sql.DataSource;
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.Advisor;
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator;
+import org.springframework.aop.support.DefaultIntroductionAdvisor;
+import org.springframework.beans.BeansException;
+
+/**
+ * @author [email protected]
+ */
+public class SeataAutoDataSourceProxyCreator extends AbstractAutoProxyCreator {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SeataAutoDataSourceProxyCreator.class);
+    private final String[] excludes;
+    private final Advisor advisor = new DefaultIntroductionAdvisor(new SeataAutoDataSourceProxyAdvice());
+
+    public SeataAutoDataSourceProxyCreator(boolean useJdkProxy, String[] excludes) {
+        this.excludes = excludes;
+        setProxyTargetClass(!useJdkProxy);
+    }
+
+    @Override
+    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource customTargetSource) throws BeansException {
+        if (LOGGER.isInfoEnabled()) {
+            LOGGER.info("Auto proxy of [{}]", beanName);
+        }
+        return new Object[]{advisor};
+    }
+
+    @Override
+    protected boolean shouldSkip(Class<?> beanClass, String beanName) {
+        return SeataProxy.class.isAssignableFrom(beanClass) ||
+            !DataSource.class.isAssignableFrom(beanClass) ||
+            Arrays.asList(excludes).contains(beanClass.getName());
+    }
+}

spring/src/main/java/io/seata/spring/annotation/datasource/SeataProxy.java

@@ -0,0 +1,22 @@
+/*
+ *  Copyright 1999-2019 Seata.io Group.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.seata.spring.annotation.datasource;
+
+/**
+ * @author [email protected]
+ */
+public interface SeataProxy {
+}