Update springboot 3.2.0

pom.xml

@@ -24,7 +24,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.1.5</version>
+        <version>3.2.0</version>
     </parent>
 
     <groupId>com.alipay.sofa</groupId>
@@ -37,7 +37,7 @@
     <properties>
         <revision>4.2.0-SNAPSHOT</revision>
         <sofa.boot.version>${revision}</sofa.boot.version>
-        <spring.boot.version>3.1.5</spring.boot.version>
+        <spring.boot.version>3.2.0</spring.boot.version>
         <!--project-->
         <java.version>17</java.version>
         <project.encoding>UTF-8</project.encoding>

sofa-boot-project/sofa-boot-core/runtime-sofa-boot/src/main/java/com/alipay/sofa/runtime/spring/ServiceBeanFactoryPostProcessor.java

@@ -35,6 +35,7 @@
 import com.alipay.sofa.runtime.spi.service.BindingConverter;
 import com.alipay.sofa.runtime.spi.service.BindingConverterContext;
 import com.alipay.sofa.runtime.spi.service.BindingConverterFactory;
+import com.alipay.sofa.runtime.spring.bean.LocalVariableTableParameterNameDiscoverer;
 import com.alipay.sofa.runtime.spring.bean.SofaBeanNameGenerator;
 import com.alipay.sofa.runtime.spring.bean.SofaParameterNameDiscoverer;
 import com.alipay.sofa.runtime.spring.factory.ReferenceFactoryBean;
@@ -60,8 +61,10 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ScannedGenericBeanDefinition;
 import org.springframework.core.DefaultParameterNameDiscoverer;
+import org.springframework.core.NativeDetector;
 import org.springframework.core.Ordered;
 import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.core.PrioritizedParameterNameDiscoverer;
 import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.core.type.MethodMetadata;
 import org.springframework.core.type.StandardMethodMetadata;
@@ -113,6 +116,11 @@ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
             if (parameterNameDiscoverer == null) {
                 parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
             }
+            // keep compatible for second jars
+            if (parameterNameDiscoverer instanceof PrioritizedParameterNameDiscoverer prioritizedParameterNameDiscoverer
+                    && !NativeDetector.inNativeImage()) {
+                prioritizedParameterNameDiscoverer.addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
+            }
             ((AbstractAutowireCapableBeanFactory) beanFactory)
                     .setParameterNameDiscoverer(new SofaParameterNameDiscoverer(parameterNameDiscoverer, referenceAnnotationWrapper));
         }

sofa-boot-project/sofa-boot-core/runtime-sofa-boot/src/main/java/com/alipay/sofa/runtime/spring/bean/LocalVariableTableParameterNameDiscoverer.java

@@ -0,0 +1,270 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 com.alipay.sofa.runtime.spring.bean;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.asm.ClassReader;
+import org.springframework.asm.ClassVisitor;
+import org.springframework.asm.Label;
+import org.springframework.asm.MethodVisitor;
+import org.springframework.asm.Opcodes;
+import org.springframework.asm.SpringAsmInfo;
+import org.springframework.asm.Type;
+import org.springframework.core.BridgeMethodResolver;
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Deprecate in spring, fork codes for compatible
+ */
+@Deprecated
+public class LocalVariableTableParameterNameDiscoverer implements ParameterNameDiscoverer {
+
+    private static final Log                               logger              = LogFactory
+                                                                                   .getLog(LocalVariableTableParameterNameDiscoverer.class);
+
+    // marker object for classes that do not have any debug info
+    private static final Map<Executable, String[]>         NO_DEBUG_INFO_MAP   = Collections
+                                                                                   .emptyMap();
+
+    // the cache uses a nested index (value is a map) to keep the top level cache relatively small in size
+    private final Map<Class<?>, Map<Executable, String[]>> parameterNamesCache = new ConcurrentHashMap<>(
+                                                                                   32);
+
+    @Override
+    @Nullable
+    public String[] getParameterNames(Method method) {
+        Method originalMethod = BridgeMethodResolver.findBridgedMethod(method);
+        return doGetParameterNames(originalMethod);
+    }
+
+    @Override
+    @Nullable
+    public String[] getParameterNames(Constructor<?> ctor) {
+        return doGetParameterNames(ctor);
+    }
+
+    @Nullable
+    private String[] doGetParameterNames(Executable executable) {
+        Class<?> declaringClass = executable.getDeclaringClass();
+        Map<Executable, String[]> map = this.parameterNamesCache.computeIfAbsent(declaringClass, this::inspectClass);
+        return (map != NO_DEBUG_INFO_MAP ? map.get(executable) : null);
+    }
+
+    /**
+     * Inspects the target class.
+     * <p>Exceptions will be logged, and a marker map returned to indicate the
+     * lack of debug information.
+     */
+    private Map<Executable, String[]> inspectClass(Class<?> clazz) {
+        InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
+        if (is == null) {
+            // We couldn't load the class file, which is not fatal as it
+            // simply means this method of discovering parameter names won't work.
+            if (logger.isDebugEnabled()) {
+                logger.debug("Cannot find '.class' file for class [" + clazz
+                             + "] - unable to determine constructor/method parameter names");
+            }
+            return NO_DEBUG_INFO_MAP;
+        }
+        // We cannot use try-with-resources here for the InputStream, since we have
+        // custom handling of the close() method in a finally-block.
+        try {
+            ClassReader classReader = new ClassReader(is);
+            Map<Executable, String[]> map = new ConcurrentHashMap<>(32);
+            classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
+            if (logger.isWarnEnabled()) {
+                logger
+                    .warn("Using deprecated '-debug' fallback for parameter name resolution. Compile the "
+                          + "affected code with '-parameters' instead or avoid its introspection: "
+                          + clazz.getName());
+            }
+            return map;
+        } catch (IOException ex) {
+            if (logger.isDebugEnabled()) {
+                logger.debug("Exception thrown while reading '.class' file for class [" + clazz
+                             + "] - unable to determine constructor/method parameter names", ex);
+            }
+        } catch (IllegalArgumentException ex) {
+            if (logger.isDebugEnabled()) {
+                logger
+                    .debug(
+                        "ASM ClassReader failed to parse class file ["
+                                + clazz
+                                + "], probably due to a new Java class file version that isn't supported yet "
+                                + "- unable to determine constructor/method parameter names", ex);
+            }
+        } finally {
+            try {
+                is.close();
+            } catch (IOException ex) {
+                // ignore
+            }
+        }
+        return NO_DEBUG_INFO_MAP;
+    }
+
+    /**
+     * Helper class that inspects all methods and constructors and then
+     * attempts to find the parameter names for the given {@link Executable}.
+     */
+    private static class ParameterNameDiscoveringVisitor extends ClassVisitor {
+
+        private static final String             STATIC_CLASS_INIT = "<clinit>";
+
+        private final Class<?>                  clazz;
+
+        private final Map<Executable, String[]> executableMap;
+
+        public ParameterNameDiscoveringVisitor(Class<?> clazz,
+                                               Map<Executable, String[]> executableMap) {
+            super(SpringAsmInfo.ASM_VERSION);
+            this.clazz = clazz;
+            this.executableMap = executableMap;
+        }
+
+        @Override
+        @Nullable
+        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
+                                         String[] exceptions) {
+            // exclude synthetic + bridged && static class initialization
+            if (!isSyntheticOrBridged(access) && !STATIC_CLASS_INIT.equals(name)) {
+                return new LocalVariableTableVisitor(this.clazz, this.executableMap, name, desc,
+                    isStatic(access));
+            }
+            return null;
+        }
+
+        private static boolean isSyntheticOrBridged(int access) {
+            return (((access & Opcodes.ACC_SYNTHETIC) | (access & Opcodes.ACC_BRIDGE)) > 0);
+        }
+
+        private static boolean isStatic(int access) {
+            return ((access & Opcodes.ACC_STATIC) > 0);
+        }
+    }
+
+    private static class LocalVariableTableVisitor extends MethodVisitor {
+
+        private static final String             CONSTRUCTOR = "<init>";
+
+        private final Class<?>                  clazz;
+
+        private final Map<Executable, String[]> executableMap;
+
+        private final String                    name;
+
+        private final Type[]                    args;
+
+        private final String[]                  parameterNames;
+
+        private final boolean                   isStatic;
+
+        private boolean                         hasLvtInfo  = false;
+
+        /*
+         * The nth entry contains the slot index of the LVT table entry holding the
+         * argument name for the nth parameter.
+         */
+        private final int[]                     lvtSlotIndex;
+
+        public LocalVariableTableVisitor(Class<?> clazz, Map<Executable, String[]> map,
+                                         String name, String desc, boolean isStatic) {
+            super(SpringAsmInfo.ASM_VERSION);
+            this.clazz = clazz;
+            this.executableMap = map;
+            this.name = name;
+            this.args = Type.getArgumentTypes(desc);
+            this.parameterNames = new String[this.args.length];
+            this.isStatic = isStatic;
+            this.lvtSlotIndex = computeLvtSlotIndices(isStatic, this.args);
+        }
+
+        @Override
+        public void visitLocalVariable(String name, String description, String signature,
+                                       Label start, Label end, int index) {
+            this.hasLvtInfo = true;
+            for (int i = 0; i < this.lvtSlotIndex.length; i++) {
+                if (this.lvtSlotIndex[i] == index) {
+                    this.parameterNames[i] = name;
+                }
+            }
+        }
+
+        @Override
+        public void visitEnd() {
+            if (this.hasLvtInfo || (this.isStatic && this.parameterNames.length == 0)) {
+                // visitLocalVariable will never be called for static no args methods
+                // which doesn't use any local variables.
+                // This means that hasLvtInfo could be false for that kind of methods
+                // even if the class has local variable info.
+                this.executableMap.put(resolveExecutable(), this.parameterNames);
+            }
+        }
+
+        private Executable resolveExecutable() {
+            ClassLoader loader = this.clazz.getClassLoader();
+            Class<?>[] argTypes = new Class<?>[this.args.length];
+            for (int i = 0; i < this.args.length; i++) {
+                argTypes[i] = ClassUtils.resolveClassName(this.args[i].getClassName(), loader);
+            }
+            try {
+                if (CONSTRUCTOR.equals(this.name)) {
+                    return this.clazz.getDeclaredConstructor(argTypes);
+                }
+                return this.clazz.getDeclaredMethod(this.name, argTypes);
+            } catch (NoSuchMethodException ex) {
+                throw new IllegalStateException(
+                    "Method ["
+                            + this.name
+                            + "] was discovered in the .class file but cannot be resolved in the class object",
+                    ex);
+            }
+        }
+
+        private static int[] computeLvtSlotIndices(boolean isStatic, Type[] paramTypes) {
+            int[] lvtIndex = new int[paramTypes.length];
+            int nextIndex = (isStatic ? 0 : 1);
+            for (int i = 0; i < paramTypes.length; i++) {
+                lvtIndex[i] = nextIndex;
+                if (isWideType(paramTypes[i])) {
+                    nextIndex += 2;
+                } else {
+                    nextIndex++;
+                }
+            }
+            return lvtIndex;
+        }
+
+        private static boolean isWideType(Type aType) {
+            // float is not a wide type
+            return (aType == Type.LONG_TYPE || aType == Type.DOUBLE_TYPE);
+        }
+    }
+
+}

sofa-boot-project/sofaboot-dependencies/pom.xml

@@ -19,7 +19,7 @@
         <maven-java-formatter-plugin.version>0.4</maven-java-formatter-plugin.version>
         <maven-pmd-plgun.version>3.19.0</maven-pmd-plgun.version>
         <maven-checkstyle-plugin.version>3.1.2</maven-checkstyle-plugin.version>
-        <maven-jacoco-plugin.version>0.8.9</maven-jacoco-plugin.version>
+        <maven-jacoco-plugin.version>0.8.11</maven-jacoco-plugin.version>
         <maven-surefire-plugin.version>3.0.0</maven-surefire-plugin.version>
         <!-- sofa stack lib-->
         <sofa.registry.version>6.1.8</sofa.registry.version>
@@ -28,11 +28,11 @@
         <sofa.common.tools.version>2.0.1</sofa.common.tools.version>
         <sofa.bolt.version>1.6.6</sofa.bolt.version>
         <sofa.hessian.version>3.5.1</sofa.hessian.version>
-        <sofa.ark.version>2.2.3</sofa.ark.version>
+        <sofa.ark.version>3.0.1-SNAPSHOT</sofa.ark.version>
         <sofa.lookout.version>1.6.1</sofa.lookout.version>
         <!--3rd lib dependency-->
-        <spring.cloud.version>2022.0.3</spring.cloud.version>
-        <asm.version>9.4</asm.version>
+        <spring.cloud.version>2023.0.0</spring.cloud.version>
+        <asm.version>9.5</asm.version>
         <fastjson.version>1.2.83</fastjson.version>
         <javassist.version>3.29.2-GA</javassist.version>
         <protobuf.version>3.22.2</protobuf.version>
@@ -537,18 +537,6 @@
                 <version>${commons.io.version}</version>
             </dependency>
 
-            <dependency>
-                <groupId>mysql</groupId>
-                <artifactId>mysql-connector-java</artifactId>
-                <version>${mysql.version}</version>
-                <exclusions>
-                    <exclusion>
-                        <groupId>com.google.protobuf</groupId>
-                        <artifactId>protobuf-java</artifactId>
-                    </exclusion>
-                </exclusions>
-            </dependency>
-
             <dependency>
                 <groupId>com.alibaba</groupId>
                 <artifactId>druid</artifactId>

sofa-boot-tests/sofa-boot-smoke-tests/sofa-boot-smoke-tests-rpc/src/main/java/com/alipay/sofa/smoke/tests/rpc/boot/RpcSofaBootApplication.java

@@ -18,16 +18,13 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.context.annotation.ComponentScan;
-import org.springframework.context.annotation.FilterType;
 
 /**
  *
  * @author yuanxuan
  * @version : RpcSofaBootApplication.java, v 0.1 2023年02月03日 15:19 yuanxuan Exp $
  */
-@SpringBootApplication
-@ComponentScan(excludeFilters = { @ComponentScan.Filter(type = FilterType.REGEX, pattern = "com.alipay.sofa.smoke.tests.rpc.boot.*") })
+@SpringBootApplication(scanBasePackages = "none")
 public class RpcSofaBootApplication {
 
     public static void main(String[] args) {

sofa-boot-tests/sofa-boot-smoke-tests/sofa-boot-smoke-tests-tracer/pom.xml

@@ -42,8 +42,8 @@
         </dependency>
 
         <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
         </dependency>
 
         <dependency>