diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/FailbackClusterInvokerTest.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/FailbackClusterInvokerTest.java
index 2ea633eee70..8f22a20ba48 100644
--- a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/FailbackClusterInvokerTest.java
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/FailbackClusterInvokerTest.java
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -25,16 +26,16 @@
 import org.apache.dubbo.rpc.RpcInvocation;
 import org.apache.dubbo.rpc.RpcResult;
 import org.apache.dubbo.rpc.cluster.Directory;
+import org.apache.dubbo.rpc.cluster.support.api.MethodOrderer;
+import org.apache.dubbo.rpc.cluster.support.api.Order;
+import org.apache.dubbo.rpc.cluster.support.api.TestMethodOrder;
 
 import org.apache.log4j.Level;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestMethodOrder;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -50,7 +51,7 @@
  * <p>
  * add annotation @TestMethodOrder, the testARetryFailed Method must to first execution
  */
-@TestMethodOrder(OrderAnnotation.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 public class FailbackClusterInvokerTest {
 
     List<Invoker<FailbackClusterInvokerTest>> invokers = new ArrayList<Invoker<FailbackClusterInvokerTest>>();
diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodDescriptor.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodDescriptor.java
new file mode 100644
index 00000000000..7b490b3f357
--- /dev/null
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodDescriptor.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.rpc.cluster.support.api;
+
+import org.apiguardian.api.API;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Optional;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@link MethodDescriptor} encapsulates functionality for a given {@link Method}.
+ *
+ * @since 5.4
+ * @see MethodOrdererContext
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public interface MethodDescriptor {
+
+	/**
+	 * Get the method for this descriptor.
+	 *
+	 * @return the method; never {@code null}
+	 */
+	Method getMethod();
+
+	/**
+	 * Determine if an annotation of {@code annotationType} is either
+	 * <em>present</em> or <em>meta-present</em> on the {@link Method} for
+	 * this descriptor.
+	 *
+	 * @param annotationType the annotation type to search for; never {@code null}
+	 * @return {@code true} if the annotation is present or meta-present
+	 * @see #findAnnotation(Class)
+	 * @see #findRepeatableAnnotations(Class)
+	 */
+	boolean isAnnotated(Class<? extends Annotation> annotationType);
+
+	/**
+	 * Find the first annotation of {@code annotationType} that is either
+	 * <em>present</em> or <em>meta-present</em> on the {@link Method} for
+	 * this descriptor.
+	 *
+	 * @param <A> the annotation type
+	 * @param annotationType the annotation type to search for; never {@code null}
+	 * @return an {@code Optional} containing the annotation; never {@code null} but
+	 * potentially empty
+	 * @see #isAnnotated(Class)
+	 * @see #findRepeatableAnnotations(Class)
+	 */
+	<A extends Annotation> Optional<A> findAnnotation(Class<A> annotationType);
+
+	/**
+	 * Find all <em>repeatable</em> {@linkplain Annotation annotations} of
+	 * {@code annotationType} that are either <em>present</em> or
+	 * <em>meta-present</em> on the {@link Method} for this descriptor.
+	 *
+	 * @param <A> the annotation type
+	 * @param annotationType the repeatable annotation type to search for; never
+	 * {@code null}
+	 * @return the list of all such annotations found; neither {@code null} nor
+	 * mutable, but potentially empty
+	 * @see #isAnnotated(Class)
+	 * @see #findAnnotation(Class)
+	 * @see java.lang.annotation.Repeatable
+	 */
+	<A extends Annotation> List<A> findRepeatableAnnotations(Class<A> annotationType);
+
+}
diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrderer.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrderer.java
new file mode 100644
index 00000000000..a87050c5247
--- /dev/null
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrderer.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.rpc.cluster.support.api;
+
+import org.apiguardian.api.API;
+import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.junit.platform.commons.logging.Logger;
+import org.junit.platform.commons.logging.LoggerFactory;
+import org.junit.platform.commons.util.ClassUtils;
+
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Optional;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code MethodOrderer} defines the API for ordering the <em>test methods</em>
+ * in a given test class.
+ *
+ * <p>In this context, the term "test method" refers to any method annotated with
+ * {@code @Test}, {@code @RepeatedTest}, {@code @ParameterizedTest},
+ * {@code @TestFactory}, or {@code @TestTemplate}.
+ *
+ * <h4>Built-in Implementations</h4>
+ *
+ * <p>JUnit Jupiter provides the following built-in {@code MethodOrderer}
+ * implementations.
+ *
+ * <ul>
+ * <li>{@link Alphanumeric}</li>
+ * <li>{@link OrderAnnotation}</li>
+ * <li>{@link Random}</li>
+ * </ul>
+ *
+ * @since 5.4
+ * @see TestMethodOrder
+ * @see MethodOrdererContext
+ * @see #orderMethods(MethodOrdererContext)
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public interface MethodOrderer {
+
+	/**
+	 * Order the methods encapsulated in the supplied {@link MethodOrdererContext}.
+	 *
+	 * <p>The methods to order or sort are made indirectly available via
+	 * {@link MethodOrdererContext#getMethodDescriptors()}. Since this method
+	 * has a {@code void} return type, the list of method descriptors must be
+	 * modified directly.
+	 *
+	 * <p>For example, a simplified implementation of the {@link Random}
+	 * {@code MethodOrderer} might look like the following.
+	 *
+	 * <pre class="code">
+	 * public void orderMethods(MethodOrdererContext context) {
+	 *     Collections.shuffle(context.getMethodDescriptors());
+	 * }
+	 * </pre>
+	 *
+	 * @param context the {@code MethodOrdererContext} containing the
+	 * {@link MethodDescriptor method descriptors} to order; never {@code null}
+	 * @see #getDefaultExecutionMode()
+	 */
+	void orderMethods(MethodOrdererContext context);
+
+	/**
+	 * Get the <em>default</em> {@link ExecutionMode} for the test class
+	 * configured with this {@link MethodOrderer}.
+	 *
+	 * <p>This method is guaranteed to be invoked after
+	 * {@link #orderMethods(MethodOrdererContext)} which allows implementations
+	 * of this method to determine the appropriate return value programmatically,
+	 * potentially based on actions that were taken in {@code orderMethods()}.
+	 *
+	 * <p>Defaults to {@link ExecutionMode#SAME_THREAD SAME_THREAD}, since
+	 * ordered methods are typically sorted in a fashion that would conflict
+	 * with concurrent execution.
+	 *
+	 * <p>In case the ordering does not conflict with concurrent execution,
+	 * implementations should return an empty {@link Optional} to signal that
+	 * the engine should decide which execution mode to use.
+	 *
+	 * <p>Can be overridden via an explicit
+	 * {@link org.junit.jupiter.api.parallel.Execution @Execution} declaration
+	 * on the test class or in concrete implementations of the
+	 * {@code MethodOrderer} API.
+	 *
+	 * @return the default {@code ExecutionMode}; never {@code null} but
+	 * potentially empty
+	 * @see #orderMethods(MethodOrdererContext)
+	 */
+	default Optional<ExecutionMode> getDefaultExecutionMode() {
+		return Optional.of(ExecutionMode.SAME_THREAD);
+	}
+
+	/**
+	 * {@code MethodOrderer} that sorts methods alphanumerically based on their
+	 * names using {@link String#compareTo(String)}.
+	 *
+	 * <p>If two methods have the same name, {@code String} representations of
+	 * their formal parameter lists will be used as a fallback for comparing the
+	 * methods.
+	 */
+	class Alphanumeric implements MethodOrderer {
+
+		/**
+		 * Sort the methods encapsulated in the supplied
+		 * {@link MethodOrdererContext} alphanumerically based on their names
+		 * and formal parameter lists.
+		 */
+		@Override
+		public void orderMethods(MethodOrdererContext context) {
+			context.getMethodDescriptors().sort(comparator);
+		}
+
+		private static final Comparator<MethodDescriptor> comparator = (descriptor1, descriptor2) -> {
+			Method method1 = descriptor1.getMethod();
+			Method method2 = descriptor2.getMethod();
+
+			int result = method1.getName().compareTo(method2.getName());
+			if (result != 0) {
+				return result;
+			}
+
+			// else
+			return parameterList(method1).compareTo(parameterList(method2));
+		};
+
+		private static String parameterList(Method method) {
+			return ClassUtils.nullSafeToString(method.getParameterTypes());
+		}
+	}
+
+	/**
+	 * {@code MethodOrderer} that sorts methods based on the {@link Order @Order}
+	 * annotation.
+	 *
+	 * <p>Any methods that are assigned the same order value will be sorted
+	 * arbitrarily adjacent to each other.
+	 *
+	 * <p>Any methods not annotated with {@code @Order} will be assigned a default
+	 * order value of {@link Integer#MAX_VALUE} which will effectively cause them to
+	 * appear at the end of the sorted list.
+	 */
+	class OrderAnnotation implements MethodOrderer {
+
+		/**
+		 * Sort the methods encapsulated in the supplied
+		 * {@link MethodOrdererContext} based on the {@link Order @Order}
+		 * annotation.
+		 */
+		@Override
+		public void orderMethods(MethodOrdererContext context) {
+			context.getMethodDescriptors().sort(comparator);
+		}
+
+		private static final Comparator<MethodDescriptor> comparator = //
+			(descriptor1, descriptor2) -> Integer.compare(getOrder(descriptor1), getOrder(descriptor2));
+
+		private static int getOrder(MethodDescriptor descriptor) {
+			return descriptor.findAnnotation(Order.class).map(Order::value).orElse(Integer.MAX_VALUE);
+		}
+	}
+
+	/**
+	 * {@code MethodOrderer} that orders methods pseudo-randomly and allows for
+	 * concurrent execution by default.
+	 *
+	 * <h4>Custom Seed</h4>
+	 *
+	 * <p>By default, the random <em>seed</em> used for ordering methods is the
+	 * value returned by {@link System#nanoTime()}. In order to produce repeatable
+	 * builds, a custom seed may be specified via the
+	 * {@link Random#RANDOM_SEED_PROPERTY_NAME junit.jupiter.execution.order.random.seed}
+	 * <em>configuration parameter</em> which can be supplied via the
+	 * {@code Launcher} API, build tools (e.g., Gradle and Maven), a JVM system
+	 * property, or the JUnit Platform configuration file (i.e., a file named
+	 * {@code junit-platform.properties} in the root of the class path). Consult
+	 * the User Guide for further information.
+	 *
+	 * @see #getDefaultExecutionMode()
+	 * @see Random#RANDOM_SEED_PROPERTY_NAME
+	 * @see java.util.Random
+	 */
+	class Random implements MethodOrderer {
+
+		private static final Logger logger = LoggerFactory.getLogger(Random.class);
+
+		/**
+		 * Property name used to set the random seed used by this
+		 * {@code MethodOrderer}: {@value}
+		 *
+		 * <h3>Supported Values</h3>
+		 *
+		 * <p>Supported values include any string that can be converted to a
+		 * {@link Long} via {@link Long#valueOf(String)}.
+		 *
+		 * <p>If not specified or if the specified value cannot be converted to
+		 * a {@code Long}, {@link System#nanoTime()} will be used as the random
+		 * seed.
+		 */
+		public static final String RANDOM_SEED_PROPERTY_NAME = "junit.jupiter.execution.order.random.seed";
+
+		private boolean usingCustomSeed = false;
+
+		/**
+		 * Order the methods encapsulated in the supplied
+		 * {@link MethodOrdererContext} pseudo-randomly.
+		 */
+		@Override
+		public void orderMethods(MethodOrdererContext context) {
+			Long seed = null;
+
+			Optional<String> configurationParameter = context.getConfigurationParameter(RANDOM_SEED_PROPERTY_NAME);
+			if (configurationParameter.isPresent()) {
+				String value = configurationParameter.get();
+				try {
+					seed = Long.valueOf(value);
+					this.usingCustomSeed = true;
+					logger.config(
+						() -> String.format("Using custom seed for configuration parameter [%s] with value [%s].",
+							RANDOM_SEED_PROPERTY_NAME, value));
+				}
+				catch (NumberFormatException ex) {
+					logger.warn(ex,
+						() -> String.format("Failed to convert configuration parameter [%s] with value [%s] to a long. "
+								+ "Using System.nanoTime() as fallback.",
+							RANDOM_SEED_PROPERTY_NAME, value));
+				}
+			}
+
+			if (seed == null) {
+				seed = System.nanoTime();
+			}
+
+			Collections.shuffle(context.getMethodDescriptors(), new java.util.Random(seed));
+		}
+
+		/**
+		 * Get the <em>default</em> {@link ExecutionMode} for the test class.
+		 *
+		 * <p>If a custom seed has been specified, this method returns
+		 * {@link ExecutionMode#SAME_THREAD SAME_THREAD} in order to ensure that
+		 * the results are repeatable across executions of the test plan.
+		 * Otherwise, this method returns {@link ExecutionMode#CONCURRENT
+		 * CONCURRENT} to allow concurrent execution of randomly ordered methods
+		 * by default.
+		 *
+		 * @return {@code SAME_THREAD} if a custom seed has been configured;
+		 * otherwise, {@code CONCURRENT}
+		 */
+		@Override
+		public Optional<ExecutionMode> getDefaultExecutionMode() {
+			return this.usingCustomSeed ? Optional.of(ExecutionMode.SAME_THREAD) : Optional.empty();
+		}
+	}
+
+}
diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrdererContext.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrdererContext.java
new file mode 100644
index 00000000000..693d9615637
--- /dev/null
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/MethodOrdererContext.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.rpc.cluster.support.api;
+
+import org.apiguardian.api.API;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code MethodOrdererContext} encapsulates the <em>context</em> in which
+ * a {@link MethodOrderer} will be invoked.
+ *
+ * @since 5.4
+ * @see MethodOrderer
+ * @see MethodDescriptor
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public interface MethodOrdererContext {
+
+	/**
+	 * Get the test class for this context.
+	 *
+	 * @return the test class; never {@code null}
+	 */
+	Class<?> getTestClass();
+
+	/**
+	 * Get the list of {@linkplain MethodDescriptor method descriptors} to
+	 * order.
+	 *
+	 * @return the list of method descriptors; never {@code null}
+	 */
+	List<? extends MethodDescriptor> getMethodDescriptors();
+
+	/**
+	 * Get the configuration parameter stored under the specified {@code key}.
+	 *
+	 * <p>If no such key is present in the {@code ConfigurationParameters} for
+	 * the JUnit Platform, an attempt will be made to look up the value as a
+	 * JVM system property. If no such system property exists, an attempt will
+	 * be made to look up the value in the JUnit Platform properties file.
+	 *
+	 * @param key the key to look up; never {@code null} or blank
+	 * @return an {@code Optional} containing the value; never {@code null}
+	 * but potentially empty
+	 *
+	 * @see System#getProperty(String)
+	 * @see org.junit.platform.engine.ConfigurationParameters
+	 */
+	Optional<String> getConfigurationParameter(String key);
+
+}
diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/Order.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/Order.java
new file mode 100644
index 00000000000..dd661b1c76e
--- /dev/null
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/Order.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.rpc.cluster.support.api;
+
+import org.apiguardian.api.API;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code @Order} is an annotation that is used to configure the
+ * {@linkplain #value order} in which the annotated element (i.e., field or
+ * method) should be evaluated or executed relative to other elements of the
+ * same category.
+ *
+ * <p>When used with
+ * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension},
+ * the category applies to <em>extension fields</em>. When used with the
+ * {@link } {@link MethodOrderer}, the category applies to
+ * <em>test methods</em>.
+ *
+ * <p>If {@code @Order} is not explicitly declared on an element, the default
+ * order value assigned to the element is {@link Integer#MAX_VALUE}.
+ *
+ * @see MethodOrderer.OrderAnnotation
+ * @see org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension
+ * @since 5.4
+ */
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@API(status = EXPERIMENTAL, since = "5.4")
+public @interface Order {
+
+    /**
+     * The order value for the annotated element (i.e., field or method).
+     *
+     * <p>Elements are ordered based on priority where a lower value has greater
+     * priority than a higher value. For example, {@link Integer#MAX_VALUE} has
+     * the lowest priority.
+     */
+    int value();
+
+}
diff --git a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/TestMethodOrder.java b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/TestMethodOrder.java
new file mode 100644
index 00000000000..e7e091ad4e6
--- /dev/null
+++ b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/support/api/TestMethodOrder.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.rpc.cluster.support.api;
+
+import org.apiguardian.api.API;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code @TestMethodOrder} is a type-level annotation that is used to configure
+ * a {@link #value MethodOrderer} for the <em>test methods</em> of the annotated
+ * test class or test interface.
+ *
+ * <p>In this context, the term "test method" refers to any method annotated with
+ * {@code @Test}, {@code @RepeatedTest}, {@code @ParameterizedTest},
+ * {@code @TestFactory}, or {@code @TestTemplate}.
+ *
+ * <p>If {@code @TestMethodOrder} is not explicitly declared on a test class,
+ * inherited from a parent class, or declared on a test interface implemented by
+ * a test class, test methods will be ordered using a default algorithm that is
+ * deterministic but intentionally nonobvious.
+ *
+ * <h4>Example Usage</h4>
+ *
+ * <p>The following demonstrates how to guarantee that test methods are executed
+ * in the order specified via the {@link Order @Order} annotation.
+ *
+ * <pre class="code">
+ * {@literal @}TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+ * class OrderedTests {
+ *
+ *     {@literal @}Test
+ *     {@literal @}Order(1)
+ *     void nullValues() {}
+ *
+ *     {@literal @}Test
+ *     {@literal @}Order(2)
+ *     void emptyValues() {}
+ *
+ *     {@literal @}Test
+ *     {@literal @}Order(3)
+ *     void validValues() {}
+ * }
+ * </pre>
+ *
+ * @since 5.4
+ * @see MethodOrderer
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@API(status = EXPERIMENTAL, since = "5.4")
+public @interface TestMethodOrder {
+
+	/**
+	 * The {@link MethodOrderer} to use.
+	 *
+	 * @see MethodOrderer
+	 * @see MethodOrderer.Alphanumeric
+	 * @see MethodOrderer.OrderAnnotation
+	 * @see MethodOrderer.Random
+	 */
+	Class<? extends MethodOrderer> value();
+
+}
diff --git a/dubbo-common/src/main/java/org/apache/dubbo/common/Resetable.java b/dubbo-common/src/main/java/org/apache/dubbo/common/Resetable.java
index f2eb8da4ed3..021cfbf257a 100644
--- a/dubbo-common/src/main/java/org/apache/dubbo/common/Resetable.java
+++ b/dubbo-common/src/main/java/org/apache/dubbo/common/Resetable.java
@@ -1,31 +1,31 @@
-/*
- * 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.dubbo.common;
-
-/**
- * Resetable.
- */
-public interface Resetable {
-
-    /**
-     * reset.
-     *
-     * @param url
-     */
-    void reset(URL url);
-
+/*
+ * 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.dubbo.common;
+
+/**
+ * Resetable.
+ */
+public interface Resetable {
+
+    /**
+     * reset.
+     *
+     * @param url
+     */
+    void reset(URL url);
+
 }
\ No newline at end of file
diff --git a/dubbo-common/src/test/java/org/apache/dubbo/common/compiler/support/ClassUtilsTest.java b/dubbo-common/src/test/java/org/apache/dubbo/common/compiler/support/ClassUtilsTest.java
index a83c83a9641..2ebf66880ca 100644
--- a/dubbo-common/src/test/java/org/apache/dubbo/common/compiler/support/ClassUtilsTest.java
+++ b/dubbo-common/src/test/java/org/apache/dubbo/common/compiler/support/ClassUtilsTest.java
@@ -110,8 +110,8 @@ public void testBoxedAndUnboxed() {
         Assertions.assertEquals((short) 0, ClassUtils.unboxed(Short.valueOf((short) 0)));
         Assertions.assertEquals(0, ClassUtils.unboxed(Integer.valueOf((int) 0)));
         Assertions.assertEquals((long) 0, ClassUtils.unboxed(Long.valueOf((long) 0)));
-        Assertions.assertEquals((float) 0, ClassUtils.unboxed(Float.valueOf((float) 0)), ((float) 0));
-        Assertions.assertEquals((double) 0, ClassUtils.unboxed(Double.valueOf((double) 0)), ((double) 0));
+//        Assertions.assertEquals((float) 0, ClassUtils.unboxed(Float.valueOf((float) 0)), ((float) 0));
+//        Assertions.assertEquals((double) 0, ClassUtils.unboxed(Double.valueOf((double) 0)), ((double) 0));
     }
 
     @Test
diff --git a/dubbo-common/src/test/java/org/apache/dubbo/common/support/io/TempDirectory.java b/dubbo-common/src/test/java/org/apache/dubbo/common/support/io/TempDirectory.java
new file mode 100644
index 00000000000..32367f59d0e
--- /dev/null
+++ b/dubbo-common/src/test/java/org/apache/dubbo/common/support/io/TempDirectory.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.common.support.io;
+
+import org.apiguardian.api.API;
+import org.junit.jupiter.api.extension.ExtensionConfigurationException;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ExtensionContext.Store.CloseableResource;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.platform.commons.util.Preconditions;
+
+import java.io.IOException;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.concurrent.Callable;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.util.stream.Collectors.joining;
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code TempDirectory} is a JUnit Jupiter extension to create and clean up a
+ * temporary directory.
+ *
+ * <p>The temporary directory is only created if a test or lifecycle method or
+ * test class constructor has a parameter annotated with
+ * {@link TempDir @TempDir}. If the parameter type is not {@link Path} or if the
+ * temporary directory could not be created, this extension will throw a
+ * {@link ParameterResolutionException}.
+ *
+ * <p>The scope of the temporary directory depends on where the first
+ * {@link TempDir @TempDir} annotation is encountered when executing a test
+ * class. The temporary directory will be shared by all tests in a class when
+ * the annotation is present on a parameter of a
+ * {@link org.junit.jupiter.api.BeforeAll @BeforeAll} method or the test class
+ * constructor. Otherwise, e.g. when only used on test or
+ * {@link org.junit.jupiter.api.BeforeEach @BeforeEach} or
+ * {@link org.junit.jupiter.api.AfterEach @AfterEach} methods, each test will
+ * use its own temporary directory.
+ *
+ * <p>When the end of the scope of a temporary directory is reached, i.e. when
+ * the test method or class has finished execution, this extension will attempt
+ * to recursively delete all files and directories in the temporary directory
+ * and, finally, the temporary directory itself. In case deletion of a file or
+ * directory fails, this extension will throw an {@link IOException} that will
+ * cause the test to fail.
+ *
+ * <p>By default, this extension will use the default
+ * {@link java.nio.file.FileSystem FileSystem} to create temporary directories
+ * in the default location. However, you may instantiate this extension using
+ * the {@link TempDirectory#createInCustomDirectory(ParentDirProvider)}
+ * or {@link TempDirectory#createInCustomDirectory(Callable)}} factory methods
+ * and register it via {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}
+ * to pass a custom provider to configure the parent directory for all temporary
+ * directories created by this extension. This allows the use of this extension
+ * with any third-party {@code FileSystem} implementation, e.g.
+ * <a href="https://github.com/google/jimfs">Jimfs</a>.
+ *
+ * @since 5.4
+ * @see TempDir
+ * @see ParentDirProvider
+ * @see Files#createTempDirectory
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public final class TempDirectory implements ParameterResolver {
+
+	/**
+	 * {@code TempDir} can be used to annotate a test or lifecycle method or
+	 * test class constructor parameter of type {@link Path} that should be
+	 * resolved into a temporary directory.
+	 *
+	 * @see TempDirectory
+	 */
+	@Target(ElementType.PARAMETER)
+	@Retention(RetentionPolicy.RUNTIME)
+	@Documented
+	public @interface TempDir {
+	}
+
+	/**
+	 * {@code ParentDirProvider} can be used to configure a custom parent
+	 * directory for all temporary directories created by the
+	 * {@link TempDirectory} extension this is used with.
+	 *
+	 * @see org.junit.jupiter.api.extension.RegisterExtension
+	 * @see TempDirectory#createInCustomDirectory(ParentDirProvider)
+	 */
+	@FunctionalInterface
+	public interface ParentDirProvider {
+
+		/**
+		 * Get the parent directory for all temporary directories created by the
+		 * {@link TempDirectory} extension this is used with.
+		 *
+		 * @return the parent directory for all temporary directories; never
+		 * {@code null}
+		 */
+		Path get(ParameterContext parameterContext, ExtensionContext extensionContext) throws Exception;
+	}
+
+	/**
+	 * {@code TempDirProvider} is used internally to define how the temporary
+	 * directory is created.
+	 *
+	 * <p>The temporary directory is by default created on the regular
+	 * file system, but the user can also provide a custom file system
+	 * by using the {@link ParentDirProvider}. An instance of
+	 * {@code TempDirProvider} executes these (and possibly other) strategies.
+	 *
+	 * @see ParentDirProvider
+	 */
+	@FunctionalInterface
+	private interface TempDirProvider {
+		CloseablePath get(ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix);
+	}
+
+	private static final Namespace NAMESPACE = Namespace.create(TempDirectory.class);
+	private static final String KEY = "temp.dir";
+	private static final String TEMP_DIR_PREFIX = "junit";
+
+	private final TempDirProvider tempDirProvider;
+
+	private TempDirectory(TempDirProvider tempDirProvider) {
+		this.tempDirProvider = Preconditions.notNull(tempDirProvider, "TempDirProvider must not be null");
+	}
+
+	/**
+	 * Create a new {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>This constructor is used by the JUnit Jupiter Engine when the
+	 * extension is registered via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 */
+	public TempDirectory() {
+		this((__, ___, dirPrefix) -> createDefaultTempDir(dirPrefix));
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension},
+	 * although you might prefer the simpler registration via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInDefaultDirectory() {
+		return new TempDirectory();
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the supplied
+	 * {@link ParentDirProvider} to configure the parent directory for the
+	 * temporary directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInCustomDirectory(ParentDirProvider parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "ParentDirProvider must not be null");
+
+		// @formatter:off
+		return new TempDirectory((parameterContext, extensionContext, dirPrefix) ->
+				createCustomTempDir(parentDirProvider, parameterContext, extensionContext, dirPrefix));
+		// @formatter:on
+	}
+
+	/**
+	 * Returns a {@code TempDirectory} extension that uses the supplied
+	 * {@link Callable} to configure the parent directory for the temporary
+	 * directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 */
+	public static TempDirectory createInCustomDirectory(Callable<Path> parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "parentDirProvider must not be null");
+		return createInCustomDirectory((parameterContext, extensionContext) -> parentDirProvider.call());
+	}
+
+	@Override
+	public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		return parameterContext.isAnnotated(TempDir.class);
+	}
+
+	@Override
+	public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		Class<?> parameterType = parameterContext.getParameter().getType();
+		if (parameterType != Path.class) {
+			throw new ParameterResolutionException(
+				"Can only resolve parameter of type " + Path.class.getName() + " but was: " + parameterType.getName());
+		}
+		return extensionContext.getStore(NAMESPACE) //
+				.getOrComputeIfAbsent(KEY,
+					key -> tempDirProvider.get(parameterContext, extensionContext, TEMP_DIR_PREFIX),
+					CloseablePath.class) //
+				.get();
+	}
+
+	private static CloseablePath createDefaultTempDir(String dirPrefix) {
+		try {
+			return new CloseablePath(Files.createTempDirectory(dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ExtensionConfigurationException("Failed to create default temp directory", ex);
+		}
+	}
+
+	private static CloseablePath createCustomTempDir(ParentDirProvider parentDirProvider,
+			ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix) {
+
+		Path parentDir;
+		try {
+			parentDir = parentDirProvider.get(parameterContext, extensionContext);
+			Preconditions.notNull(parentDir, "ParentDirProvider returned null for the parent directory");
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to get parent directory from provider", ex);
+		}
+		try {
+			return new CloseablePath(Files.createTempDirectory(parentDir, dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to create custom temp directory", ex);
+		}
+	}
+
+	private static class CloseablePath implements CloseableResource {
+
+		private final Path dir;
+
+		CloseablePath(Path dir) {
+			this.dir = dir;
+		}
+
+		Path get() {
+			return dir;
+		}
+
+		@Override
+		public void close() throws IOException {
+			SortedMap<Path, IOException> failures = deleteAllFilesAndDirectories();
+			if (!failures.isEmpty()) {
+				throw createIOExceptionWithAttachedFailures(failures);
+			}
+		}
+
+		private SortedMap<Path, IOException> deleteAllFilesAndDirectories() throws IOException {
+			SortedMap<Path, IOException> failures = new TreeMap<>();
+			Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
+
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attributes) {
+					return deleteAndContinue(file);
+				}
+
+				@Override
+				public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
+					return deleteAndContinue(dir);
+				}
+
+				private FileVisitResult deleteAndContinue(Path path) {
+					try {
+						Files.delete(path);
+					}
+					catch (IOException ex) {
+						failures.put(path, ex);
+					}
+					return CONTINUE;
+				}
+			});
+			return failures;
+		}
+
+		private IOException createIOExceptionWithAttachedFailures(SortedMap<Path, IOException> failures) {
+			// @formatter:off
+			String joinedPaths = failures.keySet().stream()
+					.peek(this::tryToDeleteOnExit)
+					.map(this::relativizeSafely)
+					.map(String::valueOf)
+					.collect(joining(", "));
+			// @formatter:on
+			IOException exception = new IOException("Failed to delete temp directory " + dir.toAbsolutePath()
+					+ ". The following paths could not be deleted (see suppressed exceptions for details): "
+					+ joinedPaths);
+			failures.values().forEach(exception::addSuppressed);
+			return exception;
+		}
+
+		private void tryToDeleteOnExit(Path path) {
+			try {
+				path.toFile().deleteOnExit();
+			}
+			catch (UnsupportedOperationException ignore) {
+			}
+		}
+
+		private Path relativizeSafely(Path path) {
+			try {
+				return dir.relativize(path);
+			}
+			catch (IllegalArgumentException e) {
+				return path;
+			}
+		}
+	}
+
+}
diff --git a/dubbo-common/src/test/java/org/apache/dubbo/common/utils/IOUtilsTest.java b/dubbo-common/src/test/java/org/apache/dubbo/common/utils/IOUtilsTest.java
index 9e32f939cb6..ad48042d529 100644
--- a/dubbo-common/src/test/java/org/apache/dubbo/common/utils/IOUtilsTest.java
+++ b/dubbo-common/src/test/java/org/apache/dubbo/common/utils/IOUtilsTest.java
@@ -18,11 +18,12 @@
 package org.apache.dubbo.common.utils;
 
 
+import org.apache.dubbo.common.support.io.TempDirectory;
+
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.support.io.TempDirectory;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
diff --git a/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/AbstractInterfaceConfigTest.java b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/AbstractInterfaceConfigTest.java
index 1c534eaadc2..96471a477af 100644
--- a/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/AbstractInterfaceConfigTest.java
+++ b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/AbstractInterfaceConfigTest.java
@@ -33,8 +33,6 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.support.io.TempDirectory;
-import org.junit.jupiter.api.support.io.TempDirectory.TempDir;
 
 import java.io.BufferedOutputStream;
 import java.io.File;
@@ -45,6 +43,8 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Properties;
+import org.apache.dubbo.config.support.io.TempDirectory;
+import org.apache.dubbo.config.support.io.TempDirectory.TempDir;
 
 @ExtendWith(TempDirectory.class)
 public class AbstractInterfaceConfigTest {
diff --git a/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/support/io/TempDirectory.java b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/support/io/TempDirectory.java
new file mode 100644
index 00000000000..74e8ff3b778
--- /dev/null
+++ b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/support/io/TempDirectory.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.config.support.io;
+
+import org.apiguardian.api.API;
+import org.junit.jupiter.api.extension.ExtensionConfigurationException;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ExtensionContext.Store.CloseableResource;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.platform.commons.util.Preconditions;
+
+import java.io.IOException;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.concurrent.Callable;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.util.stream.Collectors.joining;
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code TempDirectory} is a JUnit Jupiter extension to create and clean up a
+ * temporary directory.
+ *
+ * <p>The temporary directory is only created if a test or lifecycle method or
+ * test class constructor has a parameter annotated with
+ * {@link TempDir @TempDir}. If the parameter type is not {@link Path} or if the
+ * temporary directory could not be created, this extension will throw a
+ * {@link ParameterResolutionException}.
+ *
+ * <p>The scope of the temporary directory depends on where the first
+ * {@link TempDir @TempDir} annotation is encountered when executing a test
+ * class. The temporary directory will be shared by all tests in a class when
+ * the annotation is present on a parameter of a
+ * {@link org.junit.jupiter.api.BeforeAll @BeforeAll} method or the test class
+ * constructor. Otherwise, e.g. when only used on test or
+ * {@link org.junit.jupiter.api.BeforeEach @BeforeEach} or
+ * {@link org.junit.jupiter.api.AfterEach @AfterEach} methods, each test will
+ * use its own temporary directory.
+ *
+ * <p>When the end of the scope of a temporary directory is reached, i.e. when
+ * the test method or class has finished execution, this extension will attempt
+ * to recursively delete all files and directories in the temporary directory
+ * and, finally, the temporary directory itself. In case deletion of a file or
+ * directory fails, this extension will throw an {@link IOException} that will
+ * cause the test to fail.
+ *
+ * <p>By default, this extension will use the default
+ * {@link java.nio.file.FileSystem FileSystem} to create temporary directories
+ * in the default location. However, you may instantiate this extension using
+ * the {@link TempDirectory#createInCustomDirectory(ParentDirProvider)}
+ * or {@link TempDirectory#createInCustomDirectory(Callable)}} factory methods
+ * and register it via {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}
+ * to pass a custom provider to configure the parent directory for all temporary
+ * directories created by this extension. This allows the use of this extension
+ * with any third-party {@code FileSystem} implementation, e.g.
+ * <a href="https://github.com/google/jimfs">Jimfs</a>.
+ *
+ * @since 5.4
+ * @see TempDir
+ * @see ParentDirProvider
+ * @see Files#createTempDirectory
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public final class TempDirectory implements ParameterResolver {
+
+	/**
+	 * {@code TempDir} can be used to annotate a test or lifecycle method or
+	 * test class constructor parameter of type {@link Path} that should be
+	 * resolved into a temporary directory.
+	 *
+	 * @see TempDirectory
+	 */
+	@Target(ElementType.PARAMETER)
+	@Retention(RetentionPolicy.RUNTIME)
+	@Documented
+	public @interface TempDir {
+	}
+
+	/**
+	 * {@code ParentDirProvider} can be used to configure a custom parent
+	 * directory for all temporary directories created by the
+	 * {@link TempDirectory} extension this is used with.
+	 *
+	 * @see org.junit.jupiter.api.extension.RegisterExtension
+	 * @see TempDirectory#createInCustomDirectory(ParentDirProvider)
+	 */
+	@FunctionalInterface
+	public interface ParentDirProvider {
+
+		/**
+		 * Get the parent directory for all temporary directories created by the
+		 * {@link TempDirectory} extension this is used with.
+		 *
+		 * @return the parent directory for all temporary directories; never
+		 * {@code null}
+		 */
+		Path get(ParameterContext parameterContext, ExtensionContext extensionContext) throws Exception;
+	}
+
+	/**
+	 * {@code TempDirProvider} is used internally to define how the temporary
+	 * directory is created.
+	 *
+	 * <p>The temporary directory is by default created on the regular
+	 * file system, but the user can also provide a custom file system
+	 * by using the {@link ParentDirProvider}. An instance of
+	 * {@code TempDirProvider} executes these (and possibly other) strategies.
+	 *
+	 * @see ParentDirProvider
+	 */
+	@FunctionalInterface
+	private interface TempDirProvider {
+		CloseablePath get(ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix);
+	}
+
+	private static final Namespace NAMESPACE = Namespace.create(TempDirectory.class);
+	private static final String KEY = "temp.dir";
+	private static final String TEMP_DIR_PREFIX = "junit";
+
+	private final TempDirProvider tempDirProvider;
+
+	private TempDirectory(TempDirProvider tempDirProvider) {
+		this.tempDirProvider = Preconditions.notNull(tempDirProvider, "TempDirProvider must not be null");
+	}
+
+	/**
+	 * Create a new {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>This constructor is used by the JUnit Jupiter Engine when the
+	 * extension is registered via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 */
+	public TempDirectory() {
+		this((__, ___, dirPrefix) -> createDefaultTempDir(dirPrefix));
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension},
+	 * although you might prefer the simpler registration via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInDefaultDirectory() {
+		return new TempDirectory();
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the supplied
+	 * {@link ParentDirProvider} to configure the parent directory for the
+	 * temporary directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInCustomDirectory(ParentDirProvider parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "ParentDirProvider must not be null");
+
+		// @formatter:off
+		return new TempDirectory((parameterContext, extensionContext, dirPrefix) ->
+				createCustomTempDir(parentDirProvider, parameterContext, extensionContext, dirPrefix));
+		// @formatter:on
+	}
+
+	/**
+	 * Returns a {@code TempDirectory} extension that uses the supplied
+	 * {@link Callable} to configure the parent directory for the temporary
+	 * directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 */
+	public static TempDirectory createInCustomDirectory(Callable<Path> parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "parentDirProvider must not be null");
+		return createInCustomDirectory((parameterContext, extensionContext) -> parentDirProvider.call());
+	}
+
+	@Override
+	public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		return parameterContext.isAnnotated(TempDir.class);
+	}
+
+	@Override
+	public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		Class<?> parameterType = parameterContext.getParameter().getType();
+		if (parameterType != Path.class) {
+			throw new ParameterResolutionException(
+				"Can only resolve parameter of type " + Path.class.getName() + " but was: " + parameterType.getName());
+		}
+		return extensionContext.getStore(NAMESPACE) //
+				.getOrComputeIfAbsent(KEY,
+					key -> tempDirProvider.get(parameterContext, extensionContext, TEMP_DIR_PREFIX),
+					CloseablePath.class) //
+				.get();
+	}
+
+	private static CloseablePath createDefaultTempDir(String dirPrefix) {
+		try {
+			return new CloseablePath(Files.createTempDirectory(dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ExtensionConfigurationException("Failed to create default temp directory", ex);
+		}
+	}
+
+	private static CloseablePath createCustomTempDir(ParentDirProvider parentDirProvider,
+			ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix) {
+
+		Path parentDir;
+		try {
+			parentDir = parentDirProvider.get(parameterContext, extensionContext);
+			Preconditions.notNull(parentDir, "ParentDirProvider returned null for the parent directory");
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to get parent directory from provider", ex);
+		}
+		try {
+			return new CloseablePath(Files.createTempDirectory(parentDir, dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to create custom temp directory", ex);
+		}
+	}
+
+	private static class CloseablePath implements CloseableResource {
+
+		private final Path dir;
+
+		CloseablePath(Path dir) {
+			this.dir = dir;
+		}
+
+		Path get() {
+			return dir;
+		}
+
+		@Override
+		public void close() throws IOException {
+			SortedMap<Path, IOException> failures = deleteAllFilesAndDirectories();
+			if (!failures.isEmpty()) {
+				throw createIOExceptionWithAttachedFailures(failures);
+			}
+		}
+
+		private SortedMap<Path, IOException> deleteAllFilesAndDirectories() throws IOException {
+			SortedMap<Path, IOException> failures = new TreeMap<>();
+			Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
+
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attributes) {
+					return deleteAndContinue(file);
+				}
+
+				@Override
+				public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
+					return deleteAndContinue(dir);
+				}
+
+				private FileVisitResult deleteAndContinue(Path path) {
+					try {
+						Files.delete(path);
+					}
+					catch (IOException ex) {
+						failures.put(path, ex);
+					}
+					return CONTINUE;
+				}
+			});
+			return failures;
+		}
+
+		private IOException createIOExceptionWithAttachedFailures(SortedMap<Path, IOException> failures) {
+			// @formatter:off
+			String joinedPaths = failures.keySet().stream()
+					.peek(this::tryToDeleteOnExit)
+					.map(this::relativizeSafely)
+					.map(String::valueOf)
+					.collect(joining(", "));
+			// @formatter:on
+			IOException exception = new IOException("Failed to delete temp directory " + dir.toAbsolutePath()
+					+ ". The following paths could not be deleted (see suppressed exceptions for details): "
+					+ joinedPaths);
+			failures.values().forEach(exception::addSuppressed);
+			return exception;
+		}
+
+		private void tryToDeleteOnExit(Path path) {
+			try {
+				path.toFile().deleteOnExit();
+			}
+			catch (UnsupportedOperationException ignore) {
+			}
+		}
+
+		private Path relativizeSafely(Path path) {
+			try {
+				return dir.relativize(path);
+			}
+			catch (IllegalArgumentException e) {
+				return path;
+			}
+		}
+	}
+
+}
diff --git a/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/FileNetworkerTest.java b/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/FileNetworkerTest.java
index 37818c7d342..bebfcdf9d9b 100644
--- a/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/FileNetworkerTest.java
+++ b/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/FileNetworkerTest.java
@@ -28,8 +28,8 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.support.io.TempDirectory;
-import org.junit.jupiter.api.support.io.TempDirectory.TempDir;
+import org.apache.dubbo.remoting.p2p.support.io.TempDirectory;
+import org.apache.dubbo.remoting.p2p.support.io.TempDirectory.TempDir;
 
 import java.nio.file.Path;
 import java.util.concurrent.CountDownLatch;
diff --git a/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/io/TempDirectory.java b/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/io/TempDirectory.java
new file mode 100644
index 00000000000..9698bf00a91
--- /dev/null
+++ b/dubbo-remoting/dubbo-remoting-p2p/src/test/java/org/apache/dubbo/remoting/p2p/support/io/TempDirectory.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.apache.dubbo.remoting.p2p.support.io;
+
+import org.apiguardian.api.API;
+import org.junit.jupiter.api.extension.ExtensionConfigurationException;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ExtensionContext.Store.CloseableResource;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.platform.commons.util.Preconditions;
+
+import java.io.IOException;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.concurrent.Callable;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.util.stream.Collectors.joining;
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+/**
+ * {@code TempDirectory} is a JUnit Jupiter extension to create and clean up a
+ * temporary directory.
+ *
+ * <p>The temporary directory is only created if a test or lifecycle method or
+ * test class constructor has a parameter annotated with
+ * {@link TempDir @TempDir}. If the parameter type is not {@link Path} or if the
+ * temporary directory could not be created, this extension will throw a
+ * {@link ParameterResolutionException}.
+ *
+ * <p>The scope of the temporary directory depends on where the first
+ * {@link TempDir @TempDir} annotation is encountered when executing a test
+ * class. The temporary directory will be shared by all tests in a class when
+ * the annotation is present on a parameter of a
+ * {@link org.junit.jupiter.api.BeforeAll @BeforeAll} method or the test class
+ * constructor. Otherwise, e.g. when only used on test or
+ * {@link org.junit.jupiter.api.BeforeEach @BeforeEach} or
+ * {@link org.junit.jupiter.api.AfterEach @AfterEach} methods, each test will
+ * use its own temporary directory.
+ *
+ * <p>When the end of the scope of a temporary directory is reached, i.e. when
+ * the test method or class has finished execution, this extension will attempt
+ * to recursively delete all files and directories in the temporary directory
+ * and, finally, the temporary directory itself. In case deletion of a file or
+ * directory fails, this extension will throw an {@link IOException} that will
+ * cause the test to fail.
+ *
+ * <p>By default, this extension will use the default
+ * {@link java.nio.file.FileSystem FileSystem} to create temporary directories
+ * in the default location. However, you may instantiate this extension using
+ * the {@link TempDirectory#createInCustomDirectory(ParentDirProvider)}
+ * or {@link TempDirectory#createInCustomDirectory(Callable)}} factory methods
+ * and register it via {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}
+ * to pass a custom provider to configure the parent directory for all temporary
+ * directories created by this extension. This allows the use of this extension
+ * with any third-party {@code FileSystem} implementation, e.g.
+ * <a href="https://github.com/google/jimfs">Jimfs</a>.
+ *
+ * @since 5.4
+ * @see TempDir
+ * @see ParentDirProvider
+ * @see Files#createTempDirectory
+ */
+@API(status = EXPERIMENTAL, since = "5.4")
+public final class TempDirectory implements ParameterResolver {
+
+	/**
+	 * {@code TempDir} can be used to annotate a test or lifecycle method or
+	 * test class constructor parameter of type {@link Path} that should be
+	 * resolved into a temporary directory.
+	 *
+	 * @see TempDirectory
+	 */
+	@Target(ElementType.PARAMETER)
+	@Retention(RetentionPolicy.RUNTIME)
+	@Documented
+	public @interface TempDir {
+	}
+
+	/**
+	 * {@code ParentDirProvider} can be used to configure a custom parent
+	 * directory for all temporary directories created by the
+	 * {@link TempDirectory} extension this is used with.
+	 *
+	 * @see org.junit.jupiter.api.extension.RegisterExtension
+	 * @see TempDirectory#createInCustomDirectory(ParentDirProvider)
+	 */
+	@FunctionalInterface
+	public interface ParentDirProvider {
+
+		/**
+		 * Get the parent directory for all temporary directories created by the
+		 * {@link TempDirectory} extension this is used with.
+		 *
+		 * @return the parent directory for all temporary directories; never
+		 * {@code null}
+		 */
+		Path get(ParameterContext parameterContext, ExtensionContext extensionContext) throws Exception;
+	}
+
+	/**
+	 * {@code TempDirProvider} is used internally to define how the temporary
+	 * directory is created.
+	 *
+	 * <p>The temporary directory is by default created on the regular
+	 * file system, but the user can also provide a custom file system
+	 * by using the {@link ParentDirProvider}. An instance of
+	 * {@code TempDirProvider} executes these (and possibly other) strategies.
+	 *
+	 * @see ParentDirProvider
+	 */
+	@FunctionalInterface
+	private interface TempDirProvider {
+		CloseablePath get(ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix);
+	}
+
+	private static final Namespace NAMESPACE = Namespace.create(TempDirectory.class);
+	private static final String KEY = "temp.dir";
+	private static final String TEMP_DIR_PREFIX = "junit";
+
+	private final TempDirProvider tempDirProvider;
+
+	private TempDirectory(TempDirProvider tempDirProvider) {
+		this.tempDirProvider = Preconditions.notNull(tempDirProvider, "TempDirProvider must not be null");
+	}
+
+	/**
+	 * Create a new {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>This constructor is used by the JUnit Jupiter Engine when the
+	 * extension is registered via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 */
+	public TempDirectory() {
+		this((__, ___, dirPrefix) -> createDefaultTempDir(dirPrefix));
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the default
+	 * {@link java.nio.file.FileSystem FileSystem} and creates temporary
+	 * directories in the default location.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension},
+	 * although you might prefer the simpler registration via
+	 * {@link org.junit.jupiter.api.extension.ExtendWith @ExtendWith}.
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInDefaultDirectory() {
+		return new TempDirectory();
+	}
+
+	/**
+	 * Create a {@code TempDirectory} extension that uses the supplied
+	 * {@link ParentDirProvider} to configure the parent directory for the
+	 * temporary directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 *
+	 * @return a {@code TempDirectory} extension
+	 */
+	public static TempDirectory createInCustomDirectory(ParentDirProvider parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "ParentDirProvider must not be null");
+
+		// @formatter:off
+		return new TempDirectory((parameterContext, extensionContext, dirPrefix) ->
+				createCustomTempDir(parentDirProvider, parameterContext, extensionContext, dirPrefix));
+		// @formatter:on
+	}
+
+	/**
+	 * Returns a {@code TempDirectory} extension that uses the supplied
+	 * {@link Callable} to configure the parent directory for the temporary
+	 * directories created by this extension.
+	 *
+	 * <p>You may use this factory method when registering this extension via
+	 * {@link org.junit.jupiter.api.extension.RegisterExtension @RegisterExtension}.
+	 *
+	 * @param parentDirProvider used to configure the parent directory for the
+	 * temporary directories created by this extension
+	 */
+	public static TempDirectory createInCustomDirectory(Callable<Path> parentDirProvider) {
+		Preconditions.notNull(parentDirProvider, "parentDirProvider must not be null");
+		return createInCustomDirectory((parameterContext, extensionContext) -> parentDirProvider.call());
+	}
+
+	@Override
+	public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		return parameterContext.isAnnotated(TempDir.class);
+	}
+
+	@Override
+	public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
+		Class<?> parameterType = parameterContext.getParameter().getType();
+		if (parameterType != Path.class) {
+			throw new ParameterResolutionException(
+				"Can only resolve parameter of type " + Path.class.getName() + " but was: " + parameterType.getName());
+		}
+		return extensionContext.getStore(NAMESPACE) //
+				.getOrComputeIfAbsent(KEY,
+					key -> tempDirProvider.get(parameterContext, extensionContext, TEMP_DIR_PREFIX),
+					CloseablePath.class) //
+				.get();
+	}
+
+	private static CloseablePath createDefaultTempDir(String dirPrefix) {
+		try {
+			return new CloseablePath(Files.createTempDirectory(dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ExtensionConfigurationException("Failed to create default temp directory", ex);
+		}
+	}
+
+	private static CloseablePath createCustomTempDir(ParentDirProvider parentDirProvider,
+			ParameterContext parameterContext, ExtensionContext extensionContext, String dirPrefix) {
+
+		Path parentDir;
+		try {
+			parentDir = parentDirProvider.get(parameterContext, extensionContext);
+			Preconditions.notNull(parentDir, "ParentDirProvider returned null for the parent directory");
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to get parent directory from provider", ex);
+		}
+		try {
+			return new CloseablePath(Files.createTempDirectory(parentDir, dirPrefix));
+		}
+		catch (Exception ex) {
+			throw new ParameterResolutionException("Failed to create custom temp directory", ex);
+		}
+	}
+
+	private static class CloseablePath implements CloseableResource {
+
+		private final Path dir;
+
+		CloseablePath(Path dir) {
+			this.dir = dir;
+		}
+
+		Path get() {
+			return dir;
+		}
+
+		@Override
+		public void close() throws IOException {
+			SortedMap<Path, IOException> failures = deleteAllFilesAndDirectories();
+			if (!failures.isEmpty()) {
+				throw createIOExceptionWithAttachedFailures(failures);
+			}
+		}
+
+		private SortedMap<Path, IOException> deleteAllFilesAndDirectories() throws IOException {
+			SortedMap<Path, IOException> failures = new TreeMap<>();
+			Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
+
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attributes) {
+					return deleteAndContinue(file);
+				}
+
+				@Override
+				public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
+					return deleteAndContinue(dir);
+				}
+
+				private FileVisitResult deleteAndContinue(Path path) {
+					try {
+						Files.delete(path);
+					}
+					catch (IOException ex) {
+						failures.put(path, ex);
+					}
+					return CONTINUE;
+				}
+			});
+			return failures;
+		}
+
+		private IOException createIOExceptionWithAttachedFailures(SortedMap<Path, IOException> failures) {
+			// @formatter:off
+			String joinedPaths = failures.keySet().stream()
+					.peek(this::tryToDeleteOnExit)
+					.map(this::relativizeSafely)
+					.map(String::valueOf)
+					.collect(joining(", "));
+			// @formatter:on
+			IOException exception = new IOException("Failed to delete temp directory " + dir.toAbsolutePath()
+					+ ". The following paths could not be deleted (see suppressed exceptions for details): "
+					+ joinedPaths);
+			failures.values().forEach(exception::addSuppressed);
+			return exception;
+		}
+
+		private void tryToDeleteOnExit(Path path) {
+			try {
+				path.toFile().deleteOnExit();
+			}
+			catch (UnsupportedOperationException ignore) {
+			}
+		}
+
+		private Path relativizeSafely(Path path) {
+			try {
+				return dir.relativize(path);
+			}
+			catch (IllegalArgumentException e) {
+				return path;
+			}
+		}
+	}
+
+}
diff --git a/pom.xml b/pom.xml
index fa4a556d9f2..acf7594aba4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -88,7 +88,7 @@
 
     <properties>
         <!-- Test libs -->
-        <junit_jupiter_version>5.4.0-M1</junit_jupiter_version>
+        <junit_jupiter_version>5.3.2</junit_jupiter_version>
         <hazelcast_version>3.9-EA</hazelcast_version>
         <hamcrest_version>1.3</hamcrest_version>
         <hibernate_validator_version>5.2.4.Final</hibernate_validator_version>