diff --git a/apache-tomcat-9.0.62-src.tar.gz b/apache-tomcat-9.0.62-src.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..70676746124976f400a76d09f6076a9144f1b98d
Binary files /dev/null and b/apache-tomcat-9.0.62-src.tar.gz differ
diff --git a/fix-malformed-dtd.patch b/fix-malformed-dtd.patch
new file mode 100644
index 0000000000000000000000000000000000000000..f5f7546d221ffd1c77146afee9f00519ed1ac627
--- /dev/null
+++ b/fix-malformed-dtd.patch
@@ -0,0 +1,8 @@
+diff -up ./java/org/apache/tomcat/util/modeler/mbeans-descriptors.dtd.orig ./java/org/apache/tomcat/util/modeler/mbeans-descriptors.dtd
+--- ./java/org/apache/tomcat/util/modeler/mbeans-descriptors.dtd.orig	2023-02-07 14:11:25.294179017 -0500
++++ ./java/org/apache/tomcat/util/modeler/mbeans-descriptors.dtd	2023-02-07 14:11:28.629196705 -0500
+@@ -1,4 +1,3 @@
+-<?xml version="1.0" encoding="UTF-8"?>
+ <!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
diff --git a/tomcat-9.0-JDTCompiler.patch b/tomcat-9.0-JDTCompiler.patch
new file mode 100644
index 0000000000000000000000000000000000000000..edf156aaa0911cbb94a786413e25e384b440555a
--- /dev/null
+++ b/tomcat-9.0-JDTCompiler.patch
@@ -0,0 +1,24 @@
+diff -up ./java/org/apache/jasper/compiler/JDTCompiler.java ./java/org/apache/jasper/compiler/JDTCompiler.java
+index 2e361f2..277d8f4 100644
+--- java/org/apache/jasper/compiler/JDTCompiler.java
++++ java/org/apache/jasper/compiler/JDTCompiler.java
+@@ -310,7 +310,7 @@ public class JDTCompiler extends org.apache.jasper.compiler.Compiler {
+             } else if(opt.equals("15")) {
+                 settings.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_15);
+             } else if(opt.equals("16")) {
+-                settings.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_16);
++                settings.put(CompilerOptions.OPTION_Source, "16");
+             } else if(opt.equals("17")) {
+                 // Constant not available in latest ECJ version that runs on
+                 // Java 8.
+@@ -377,8 +377,8 @@ public class JDTCompiler extends org.apache.jasper.compiler.Compiler {
+                 settings.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_15);
+                 settings.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_15);
+             } else if(opt.equals("16")) {
+-                settings.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_16);
+-                settings.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_16);
++                settings.put(CompilerOptions.OPTION_TargetPlatform, "16");
++                settings.put(CompilerOptions.OPTION_Compliance, "16");
+             } else if(opt.equals("17")) {
+                 // Constant not available in latest ECJ version that runs on
+                 // Java 8.
diff --git a/tomcat-9.0-memory-leak.patch b/tomcat-9.0-memory-leak.patch
new file mode 100644
index 0000000000000000000000000000000000000000..00e6e562e312f1940514325e7c16078f41dfd379
--- /dev/null
+++ b/tomcat-9.0-memory-leak.patch
@@ -0,0 +1,345 @@
+diff --git a/java/org/apache/catalina/loader/WebappClassLoaderBase.java b/java/org/apache/catalina/loader/WebappClassLoaderBase.java
+index 8746b6b..dc878c6 100644
+--- a/java/org/apache/catalina/loader/WebappClassLoaderBase.java
++++ b/java/org/apache/catalina/loader/WebappClassLoaderBase.java
+@@ -1820,41 +1820,13 @@ public abstract class WebappClassLoaderBase extends URLClassLoader
+                     // shutting down the executor
+                     boolean usingExecutor = false;
+                     try {
+-
+-                        // Runnable wrapped by Thread
+-                        // "target" in Sun/Oracle JDK
+-                        // "runnable" in IBM JDK
+-                        // "action" in Apache Harmony
+-                        Object target = null;
+-                        for (String fieldName : new String[] { "target", "runnable", "action" }) {
+-                            try {
+-                                Field targetField = thread.getClass().getDeclaredField(fieldName);
+-                                targetField.setAccessible(true);
+-                                target = targetField.get(thread);
+-                                break;
+-                            } catch (NoSuchFieldException nfe) {
+-                                continue;
+-                            }
+-                        }
+-
+-                        // "java.util.concurrent" code is in public domain,
+-                        // so all implementations are similar including our
+-                        // internal fork.
+-                        if (target != null && target.getClass().getCanonicalName() != null &&
+-                                (target.getClass().getCanonicalName().equals(
+-                                        "org.apache.tomcat.util.threads.ThreadPoolExecutor.Worker") ||
+-                                        target.getClass().getCanonicalName().equals(
+-                                                "java.util.concurrent.ThreadPoolExecutor.Worker"))) {
+-                            Field executorField = target.getClass().getDeclaredField("this$0");
+-                            executorField.setAccessible(true);
+-                            Object executor = executorField.get(target);
+-                            if (executor instanceof ThreadPoolExecutor) {
+-                                ((ThreadPoolExecutor) executor).shutdownNow();
+-                                usingExecutor = true;
+-                            } else if (executor instanceof java.util.concurrent.ThreadPoolExecutor) {
+-                                ((java.util.concurrent.ThreadPoolExecutor) executor).shutdownNow();
+-                                usingExecutor = true;
+-                            }
++			Object executor = JreCompat.getInstance().getExecutor(thread);
++                        if (executor instanceof ThreadPoolExecutor) {
++                            ((ThreadPoolExecutor) executor).shutdownNow();
++                            usingExecutor = true;
++                        } else if (executor instanceof java.util.concurrent.ThreadPoolExecutor) {
++                            ((java.util.concurrent.ThreadPoolExecutor) executor).shutdownNow();
++                            usingExecutor = true;
+                         }
+                     } catch (NoSuchFieldException | IllegalAccessException | RuntimeException e) {
+                         // InaccessibleObjectException is only available in Java 9+,
+@@ -2306,6 +2278,12 @@ public abstract class WebappClassLoaderBase extends URLClassLoader
+ 
+ 
+     private void clearReferencesObjectStreamClassCaches() {
++	if (JreCompat.isJre19Available()) {
++            // The memory leak this fixes has been fixed in Java 19 onwards,
++            // 17.0.4 onwards and 11.0.16 onwards
++            // See https://bugs.openjdk.java.net/browse/JDK-8277072
++            return;
++        }
+         try {
+             Class<?> clazz = Class.forName("java.io.ObjectStreamClass$Caches");
+             clearCache(clazz, "localDescs");
+@@ -2333,14 +2311,19 @@ public abstract class WebappClassLoaderBase extends URLClassLoader
+             throws ReflectiveOperationException, SecurityException, ClassCastException {
+         Field f = target.getDeclaredField(mapName);
+         f.setAccessible(true);
+-        Map<?,?> map = (Map<?,?>) f.get(null);
+-        Iterator<?> keys = map.keySet().iterator();
+-        while (keys.hasNext()) {
+-            Object key = keys.next();
+-            if (key instanceof Reference) {
+-                Object clazz = ((Reference<?>) key).get();
+-                if (loadedByThisOrChild(clazz)) {
+-                    keys.remove();
++	Object map = f.get(null);
++        // Avoid trying to clear references if Tomcat is running on a JRE that
++        // includes the fix for this memory leak
++        // See https://bugs.openjdk.java.net/browse/JDK-8277072
++        if (map instanceof Map<?,?>) {
++            Iterator<?> keys = ((Map<?,?>) map).keySet().iterator();
++            while (keys.hasNext()) {
++                Object key = keys.next();
++                if (key instanceof Reference) {
++                    Object clazz = ((Reference<?>) key).get();
++                    if (loadedByThisOrChild(clazz)) {
++                        keys.remove();
++                    }
+                 }
+             }
+         }
+diff --git a/java/org/apache/tomcat/util/compat/JreCompat.java b/java/org/apache/tomcat/util/compat/JreCompat.java
+index 62df145..e5df728 100644
+--- a/java/org/apache/tomcat/util/compat/JreCompat.java
++++ b/java/org/apache/tomcat/util/compat/JreCompat.java
+@@ -19,6 +19,7 @@ package org.apache.tomcat.util.compat;
+ import java.io.File;
+ import java.io.IOException;
+ import java.lang.reflect.AccessibleObject;
++import java.lang.reflect.Field;
+ import java.lang.reflect.InvocationTargetException;
+ import java.lang.reflect.Method;
+ import java.net.SocketAddress;
+@@ -45,6 +46,7 @@ public class JreCompat {
+ 
+     private static final JreCompat instance;
+     private static final boolean graalAvailable;
++    private static final boolean jre19Available;
+     private static final boolean jre16Available;
+     private static final boolean jre11Available;
+     private static final boolean jre9Available;
+@@ -67,18 +69,26 @@ public class JreCompat {
+ 
+         // This is Tomcat 9 with a minimum Java version of Java 8.
+         // Look for the highest supported JVM first
+-        if (Jre16Compat.isSupported()) {
++	if (Jre19Compat.isSupported()) {
++            instance = new Jre19Compat();
++            jre9Available = true;
++            jre16Available = true;
++            jre19Available = true;
++        } else if (Jre16Compat.isSupported()) {
+             instance = new Jre16Compat();
+             jre9Available = true;
+             jre16Available = true;
++            jre19Available = false;
+         } else if (Jre9Compat.isSupported()) {
+             instance = new Jre9Compat();
+             jre9Available = true;
+             jre16Available = false;
++            jre19Available = false;
+         } else {
+             instance = new JreCompat();
+             jre9Available = false;
+             jre16Available = false;
++            jre19Available = false;
+         }
+         jre11Available = instance.jarFileRuntimeMajorVersion() >= 11;
+ 
+@@ -124,6 +134,9 @@ public class JreCompat {
+         return jre16Available;
+     }
+ 
++    public static boolean isJre19Available() {
++        return jre19Available;
++    }
+ 
+     // Java 8 implementation of Java 9 methods
+ 
+@@ -303,6 +316,8 @@ public class JreCompat {
+     }
+ 
+ 
++    // Java 8 implementations of Java 16 methods
++
+     /**
+      * Return Unix domain socket address for given path.
+      * @param path The path
+@@ -329,4 +344,63 @@ public class JreCompat {
+     public SocketChannel openUnixDomainSocketChannel() {
+         throw new UnsupportedOperationException(sm.getString("jreCompat.noUnixDomainSocket"));
+     }
++
++
++    // Java 8 implementations of Java 19 methods
++
++    /**
++     * Obtains the executor, if any, used to create the provided thread.
++     *
++     * @param thread    The thread to examine
++     *
++     * @return  The executor, if any, that created the provided thread
++     *
++     * @throws NoSuchFieldException
++     *              If a field used via reflection to obtain the executor cannot
++     *              be found
++     * @throws SecurityException
++     *              If a security exception occurs while trying to identify the
++     *              executor
++     * @throws IllegalArgumentException
++     *              If the instance object does not match the class of the field
++     *              when obtaining a field value via reflection
++     * @throws IllegalAccessException
++     *              If a field is not accessible due to access restrictions
++     */
++    public Object getExecutor(Thread thread)
++            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
++
++        Object result = null;
++
++        // Runnable wrapped by Thread
++        // "target" in Sun/Oracle JDK
++        // "runnable" in IBM JDK
++        // "action" in Apache Harmony
++        Object target = null;
++        for (String fieldName : new String[] { "target", "runnable", "action" }) {
++            try {
++                Field targetField = thread.getClass().getDeclaredField(fieldName);
++                targetField.setAccessible(true);
++                target = targetField.get(thread);
++                break;
++            } catch (NoSuchFieldException nfe) {
++                continue;
++            }
++        }
++
++        // "java.util.concurrent" code is in public domain,
++        // so all implementations are similar including our
++        // internal fork.
++        if (target != null && target.getClass().getCanonicalName() != null &&
++                (target.getClass().getCanonicalName().equals(
++                        "org.apache.tomcat.util.threads.ThreadPoolExecutor.Worker") ||
++                        target.getClass().getCanonicalName().equals(
++                                "java.util.concurrent.ThreadPoolExecutor.Worker"))) {
++            Field executorField = target.getClass().getDeclaredField("this$0");
++            executorField.setAccessible(true);
++            result = executorField.get(target);
++        }
++
++        return result;
++    }
+ }
+diff --git a/java/org/apache/tomcat/util/compat/LocalStrings.properties b/java/org/apache/tomcat/util/compat/LocalStrings.properties
+index 79427da..c4c2f7d 100644
+--- a/java/org/apache/tomcat/util/compat/LocalStrings.properties
++++ b/java/org/apache/tomcat/util/compat/LocalStrings.properties
+@@ -16,6 +16,8 @@
+ jre16Compat.javaPre16=Class not found so assuming code is running on a pre-Java 16 JVM
+ jre16Compat.unexpected=Failed to create references to Java 16 classes and methods
+ 
++jre19Compat.javaPre19=Class not found so assuming code is running on a pre-Java 19 JVM
++
+ jre9Compat.invalidModuleUri=The module URI provided [{0}] could not be converted to a URL for the JarScanner to process
+ jre9Compat.javaPre9=Class not found so assuming code is running on a pre-Java 9 JVM
+ jre9Compat.unexpected=Failed to create references to Java 9 classes and methods
+diff --git a/webapps/docs/config/context.xml b/webapps/docs/config/context.xml
+index d118196..42dfe38 100644
+--- a/webapps/docs/config/context.xml
++++ b/webapps/docs/config/context.xml
+@@ -769,7 +769,11 @@
+         therefore requires that the command line option
+         <code>-XaddExports:java.base/java.io=ALL-UNNAMED</code> is set
+         when running on Java 9 and above. If not specified, the default value of
+-        <code>true</code> will be used.</p>
++	<code>true</code> will be used.</p>
++	<p>The memory leak associated with <code>ObjectStreamClass</code> has
++        been fixed in Java 19 onwards, Java 17.0.4 onwards and Java 11.0.16
++        onwards. The check will be disabled when running on a version
++        of Java that contains the fix.</p>
+       </attribute>
+ 
+       <attribute name="clearReferencesRmiTargets" required="false">
+diff --git a/java/org/apache/tomcat/util/compat/Jre19Compat.java b/java/org/apache/tomcat/util/compat/Jre19Compat.java
+new file mode 100644
+index 0000000000..fb94810b40
+--- /dev/null
++++ b/java/org/apache/tomcat/util/compat/Jre19Compat.java
+@@ -0,0 +1,84 @@
++/*
++ *  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 org.apache.tomcat.util.compat;
++
++import java.lang.reflect.Field;
++
++import org.apache.juli.logging.Log;
++import org.apache.juli.logging.LogFactory;
++import org.apache.tomcat.util.res.StringManager;
++
++public class Jre19Compat extends Jre16Compat {
++
++    private static final Log log = LogFactory.getLog(Jre19Compat.class);
++    private static final StringManager sm = StringManager.getManager(Jre19Compat.class);
++
++    private static final boolean supported;
++
++    static {
++        // Don't need any Java 19 specific classes (yet) so just test for one of
++        // the new ones for now.
++        Class<?> c1 = null;
++        try {
++            c1 = Class.forName("java.lang.WrongThreadException");
++        } catch (ClassNotFoundException cnfe) {
++            // Must be pre-Java 16
++            log.debug(sm.getString("jre19Compat.javaPre19"), cnfe);
++        }
++
++        supported = (c1 != null);
++    }
++
++    static boolean isSupported() {
++        return supported;
++    }
++
++    @Override
++    public Object getExecutor(Thread thread)
++            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
++
++        Object result = super.getExecutor(thread);
++
++        if (result == null) {
++            Object holder = null;
++            Object task = null;
++            try {
++                Field holderField = thread.getClass().getDeclaredField("holder");
++                holderField.setAccessible(true);
++                holder = holderField.get(thread);
++
++                Field taskField = holder.getClass().getDeclaredField("task");
++                taskField.setAccessible(true);
++                task = taskField.get(holder);
++            } catch (NoSuchFieldException nfe) {
++                return null;
++            }
++
++            if (task!= null && task.getClass().getCanonicalName() != null &&
++                    (task.getClass().getCanonicalName().equals(
++                            "org.apache.tomcat.util.threads.ThreadPoolExecutor.Worker") ||
++                            task.getClass().getCanonicalName().equals(
++                                    "java.util.concurrent.ThreadPoolExecutor.Worker"))) {
++                Field executorField = task.getClass().getDeclaredField("this$0");
++                executorField.setAccessible(true);
++                result = executorField.get(task);
++            }
++        }
++
++        return result;
++    }
++}
diff --git a/tomcat-9.0.conf b/tomcat-9.0.conf
index 6e9eed13a5c5af13a83f68080ed8e051af2db8d5..e5fa60a5eefd741f0f3893a8a740a2d31b7e5aa9 100644
--- a/tomcat-9.0.conf
+++ b/tomcat-9.0.conf
@@ -35,7 +35,7 @@ CATALINA_TMPDIR="/var/cache/tomcat/temp"
 #JAVA_OPTS="-Djava.library.path=/usr/lib"
 
 # Set default javax.sql.DataSource factory to apache commons one. See rhbz#1214381
-JAVA_OPTS="-Djavax.sql.DataSource.Factory=org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory"
+JAVA_OPTS="-Djavax.sql.DataSource.Factory=org.apache.commons.dbcp.BasicDataSourceFactory"
 
 # You can change your tomcat locale here
 #LANG="en_US"
diff --git a/tomcat.spec b/tomcat.spec
index 61f5250f8cdeb2ba682f8f481f35ade5ca7dd1e1..69915c876000e2a5f106ed6f7070e72228180025 100644
--- a/tomcat.spec
+++ b/tomcat.spec
@@ -1,4 +1,4 @@
-%define anolis_release 1
+%define anolis_release		2
 
 %global jspspec 2.3
 %global major_version 9
@@ -53,6 +53,9 @@ Patch2:        %{name}-build.patch
 Patch3:        %{name}-%{major_version}.%{minor_version}-catalina-policy.patch
 Patch4:        rhbz-1857043.patch
 Patch6:        %{name}-%{major_version}.%{minor_version}-bnd-annotation.patch
+Patch7:	tomcat-9.0-memory-leak.patch
+Patch8:	fix-malformed-dtd.patch
+Patch9:	tomcat-9.0-JDTCompiler.patch
 
 BuildArch:     noarch
 
@@ -520,6 +523,11 @@ fi
 %doc {NOTICE,RELEASE*}
 
 %changelog
+* Mon Jun 16 2025 wenyuzifang <lzx02244079@alibaba-inc.com> - 1:9.0.105-2
+- Applied patch to ensure Java 16 compatibility and fix issues caused by missing ECJ constants.
+- Updated to version 9.0.105.
+- Ensured compatibility with latest ECJ standards for robust compilation processes.
+
 * Tue Jun 10 2025 wh02252983 <wh02252983@alibaba-inc.com> - 1:9.0.105-1
 - update to 9.0.105
 - Fix CVE-2025-46701
@@ -568,4 +576,4 @@ fi
 - Update to 9.0.65
 
 * Mon Jun 20 2022 mgb01105731 <mgb01105731@alibaba-inc.com> - 1:9.0.63-1
-- Init from upstream version 9.0.63
+- Init from upstream version 9.0.63
\ No newline at end of file