You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by su...@apache.org on 2022/12/16 06:25:11 UTC
[shardingsphere] branch master updated: Add ConstructorAdvisorBuilder, InstanceMethodAdvisorBuilder and StaticMethodAdvisorBuilder (#22904)
This is an automated email from the ASF dual-hosted git repository.
sunnianjun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 77f15b3f646 Add ConstructorAdvisorBuilder, InstanceMethodAdvisorBuilder and StaticMethodAdvisorBuilder (#22904)
77f15b3f646 is described below
commit 77f15b3f64641403ed9137ba8094b339107092d4
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Fri Dec 16 14:25:05 2022 +0800
Add ConstructorAdvisorBuilder, InstanceMethodAdvisorBuilder and StaticMethodAdvisorBuilder (#22904)
* Add ConstructorAdvisorBuilder, InstanceMethodAdvisorBuilder and StaticMethodAdvisorBuilder
---
.../agent/core/transformer/AgentTransformer.java | 205 +--------------------
...TransformationPoint.java => MethodAdvisor.java} | 8 +-
.../builder/ConstructorAdvisorBuilder.java | 107 +++++++++++
.../builder/InstanceMethodAdvisorBuilder.java | 132 +++++++++++++
.../builder/StaticMethodAdvisorBuilder.java | 130 +++++++++++++
5 files changed, 379 insertions(+), 203 deletions(-)
diff --git a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformer.java b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformer.java
index a05393b2a18..24d3eb4da0e 100644
--- a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformer.java
+++ b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformer.java
@@ -19,46 +19,20 @@ package org.apache.shardingsphere.agent.core.transformer;
import lombok.RequiredArgsConstructor;
import net.bytebuddy.agent.builder.AgentBuilder.Transformer;
-import net.bytebuddy.description.method.MethodDescription;
-import net.bytebuddy.description.method.MethodDescription.InDefinedShape;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.DynamicType.Builder;
import net.bytebuddy.implementation.FieldAccessor;
-import net.bytebuddy.implementation.MethodDelegation;
-import net.bytebuddy.implementation.SuperMethodCall;
-import net.bytebuddy.implementation.bind.annotation.Morph;
import net.bytebuddy.jar.asm.Opcodes;
-import net.bytebuddy.matcher.ElementMatchers;
import net.bytebuddy.utility.JavaModule;
import org.apache.shardingsphere.agent.config.advisor.AdvisorConfiguration;
-import org.apache.shardingsphere.agent.config.advisor.ConstructorAdvisorConfiguration;
-import org.apache.shardingsphere.agent.config.advisor.InstanceMethodAdvisorConfiguration;
-import org.apache.shardingsphere.agent.config.advisor.StaticMethodAdvisorConfiguration;
import org.apache.shardingsphere.agent.config.plugin.PluginConfiguration;
import org.apache.shardingsphere.agent.core.logging.LoggerFactory;
-import org.apache.shardingsphere.agent.core.plugin.OverrideArgsInvoker;
import org.apache.shardingsphere.agent.core.plugin.TargetAdviceObject;
-import org.apache.shardingsphere.agent.core.plugin.advice.ConstructorAdvice;
-import org.apache.shardingsphere.agent.core.plugin.advice.InstanceMethodAroundAdvice;
-import org.apache.shardingsphere.agent.core.plugin.advice.StaticMethodAroundAdvice;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.ConstructorInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.InstanceMethodAroundInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.InstanceMethodInterceptorArgsOverride;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.StaticMethodAroundInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.StaticMethodInterceptorArgsOverride;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedConstructorInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedInstanceMethodAroundInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedInstanceMethodInterceptorArgsOverride;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedStaticMethodAroundInterceptor;
-import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedStaticMethodInterceptorArgsOverride;
-import org.apache.shardingsphere.agent.core.plugin.loader.AdviceInstanceLoader;
+import org.apache.shardingsphere.agent.core.transformer.builder.ConstructorAdvisorBuilder;
+import org.apache.shardingsphere.agent.core.transformer.builder.InstanceMethodAdvisorBuilder;
+import org.apache.shardingsphere.agent.core.transformer.builder.StaticMethodAdvisorBuilder;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
/**
* Agent transformer.
@@ -84,176 +58,9 @@ public final class AgentTransformer implements Transformer {
}
Builder<?> result = builder.defineField(EXTRA_DATA, Object.class, Opcodes.ACC_PRIVATE | Opcodes.ACC_VOLATILE).implement(TargetAdviceObject.class).intercept(FieldAccessor.ofField(EXTRA_DATA));
AdvisorConfiguration advisorConfig = advisorConfigs.get(typeDescription.getTypeName());
- result = interceptConstructor(result, typeDescription, classLoader, advisorConfig.getConstructorAdvisors());
- result = interceptStaticMethod(result, typeDescription, classLoader, advisorConfig.getStaticMethodAdvisors());
- result = interceptInstanceMethod(result, typeDescription, classLoader, advisorConfig.getInstanceMethodAdvisors());
+ result = new ConstructorAdvisorBuilder(pluginConfigs, advisorConfig.getConstructorAdvisors(), isEnhancedForProxy, typeDescription, classLoader).create(result);
+ result = new InstanceMethodAdvisorBuilder(pluginConfigs, advisorConfig.getInstanceMethodAdvisors(), isEnhancedForProxy, typeDescription, classLoader).create(result);
+ result = new StaticMethodAdvisorBuilder(pluginConfigs, advisorConfig.getStaticMethodAdvisors(), isEnhancedForProxy, typeDescription, classLoader).create(result);
return result;
}
-
- private Builder<?> interceptConstructor(final Builder<?> builder, final TypeDescription description,
- final ClassLoader classLoader, final Collection<ConstructorAdvisorConfiguration> constructorAdvisorConfigs) {
- Collection<AgentTransformationPoint<? extends ConstructorInterceptor>> constructorAdviceComposePoints = description.getDeclaredMethods().stream()
- .filter(MethodDescription::isConstructor)
- .map(each -> getMatchedTransformationPoint(each, classLoader, constructorAdvisorConfigs))
- .filter(Objects::nonNull)
- .collect(Collectors.toList());
- Builder<?> result = builder;
- for (AgentTransformationPoint<? extends ConstructorInterceptor> each : constructorAdviceComposePoints) {
- try {
- result = result.constructor(ElementMatchers.is(each.getDescription()))
- .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration().to(each.getInterceptor())));
- // CHECKSTYLE:OFF
- } catch (final Throwable ex) {
- // CHECKSTYLE:ON
- LOGGER.error("Failed to load advice class: {}.", description.getTypeName(), ex);
- }
- }
- return result;
- }
-
- private AgentTransformationPoint<? extends ConstructorInterceptor> getMatchedTransformationPoint(final InDefinedShape methodDescription, final ClassLoader classLoader,
- final Collection<ConstructorAdvisorConfiguration> constructorAdvisorConfigs) {
- List<ConstructorAdvisorConfiguration> matchedConstructorAdvisorConfigs = constructorAdvisorConfigs
- .stream().filter(each -> each.getPointcut().matches(methodDescription)).collect(Collectors.toList());
- if (matchedConstructorAdvisorConfigs.isEmpty()) {
- return null;
- }
- if (1 == matchedConstructorAdvisorConfigs.size()) {
- return new AgentTransformationPoint<>(
- methodDescription, new ConstructorInterceptor(loadAdviceInstance(matchedConstructorAdvisorConfigs.get(0).getAdviceClassName(), classLoader)));
- }
- Collection<ConstructorAdvice> constructorAdvices = matchedConstructorAdvisorConfigs.stream()
- .map(ConstructorAdvisorConfiguration::getAdviceClassName)
- .map(each -> (ConstructorAdvice) loadAdviceInstance(each, classLoader))
- .collect(Collectors.toList());
- return new AgentTransformationPoint<>(methodDescription, new ComposedConstructorInterceptor(constructorAdvices));
- }
-
- private Builder<?> interceptStaticMethod(final Builder<?> builder, final TypeDescription description,
- final ClassLoader classLoader, final Collection<StaticMethodAdvisorConfiguration> staticMethodAdvisorConfigs) {
- Collection<AgentTransformationPoint<?>> staticMethodAdvicePoints = description.getDeclaredMethods().stream()
- .filter(each -> each.isStatic() && !(each.isAbstract() || each.isSynthetic()))
- .map(each -> getMatchedStaticMethodPoint(staticMethodAdvisorConfigs, each, classLoader))
- .filter(Objects::nonNull)
- .collect(Collectors.toList());
- Builder<?> result = builder;
- for (AgentTransformationPoint<?> each : staticMethodAdvicePoints) {
- try {
- if (each.getInterceptor() instanceof StaticMethodInterceptorArgsOverride) {
- result = result.method(ElementMatchers.is(each.getDescription()))
- .intercept(MethodDelegation.withDefaultConfiguration().withBinders(Morph.Binder.install(OverrideArgsInvoker.class)).to(each.getInterceptor()));
- } else {
- result = result.method(ElementMatchers.is(each.getDescription())).intercept(MethodDelegation.withDefaultConfiguration().to(each.getInterceptor()));
- }
- // CHECKSTYLE:OFF
- } catch (final Throwable ex) {
- // CHECKSTYLE:ON
- LOGGER.error("Failed to load advice class: {}.", description.getTypeName(), ex);
- }
- }
- return result;
- }
-
- private AgentTransformationPoint<?> getMatchedStaticMethodPoint(final Collection<StaticMethodAdvisorConfiguration> staticMethodAdvisorConfigs,
- final InDefinedShape methodDescription, final ClassLoader classLoader) {
- List<StaticMethodAdvisorConfiguration> matchedAdvisors = staticMethodAdvisorConfigs.stream().filter(each -> each.getPointcut().matches(methodDescription)).collect(Collectors.toList());
- if (matchedAdvisors.isEmpty()) {
- return null;
- }
- if (1 == matchedAdvisors.size()) {
- return getSingleStaticMethodPoint(methodDescription, matchedAdvisors.get(0), classLoader);
- }
- return getComposedStaticMethodPoint(methodDescription, matchedAdvisors, classLoader);
- }
-
- private AgentTransformationPoint<?> getSingleStaticMethodPoint(final InDefinedShape methodDescription,
- final StaticMethodAdvisorConfiguration staticMethodAdvisorConfig, final ClassLoader classLoader) {
- StaticMethodAroundAdvice staticMethodAroundAdvice = loadAdviceInstance(staticMethodAdvisorConfig.getAdviceClassName(), classLoader);
- return staticMethodAdvisorConfig.isOverrideArgs()
- ? new AgentTransformationPoint<>(methodDescription, new StaticMethodInterceptorArgsOverride(staticMethodAroundAdvice))
- : new AgentTransformationPoint<>(methodDescription, new StaticMethodAroundInterceptor(staticMethodAroundAdvice));
- }
-
- private AgentTransformationPoint<?> getComposedStaticMethodPoint(final InDefinedShape methodDescription,
- final Collection<StaticMethodAdvisorConfiguration> staticMethodAdvisorConfigs, final ClassLoader classLoader) {
- Collection<StaticMethodAroundAdvice> staticMethodAroundAdvices = new LinkedList<>();
- boolean isArgsOverride = false;
- for (StaticMethodAdvisorConfiguration each : staticMethodAdvisorConfigs) {
- if (each.isOverrideArgs()) {
- isArgsOverride = true;
- }
- if (null != each.getAdviceClassName()) {
- staticMethodAroundAdvices.add(loadAdviceInstance(each.getAdviceClassName(), classLoader));
- }
- }
- return isArgsOverride ? new AgentTransformationPoint<>(methodDescription, new ComposedStaticMethodInterceptorArgsOverride(staticMethodAroundAdvices))
- : new AgentTransformationPoint<>(methodDescription, new ComposedStaticMethodAroundInterceptor(staticMethodAroundAdvices));
- }
-
- private Builder<?> interceptInstanceMethod(final Builder<?> builder, final TypeDescription description,
- final ClassLoader classLoader, final Collection<InstanceMethodAdvisorConfiguration> instanceMethodAdvisorConfigs) {
- Collection<AgentTransformationPoint<?>> instanceMethodAdviceComposePoints = description.getDeclaredMethods().stream()
- .filter(each -> !(each.isAbstract() || each.isSynthetic()))
- .map(each -> getMatchedInstanceMethodPoint(instanceMethodAdvisorConfigs, each, classLoader))
- .filter(Objects::nonNull)
- .collect(Collectors.toList());
- Builder<?> result = builder;
- for (AgentTransformationPoint<?> each : instanceMethodAdviceComposePoints) {
- try {
- if (each.getInterceptor() instanceof InstanceMethodInterceptorArgsOverride) {
- result = result.method(ElementMatchers.is(each.getDescription()))
- .intercept(MethodDelegation.withDefaultConfiguration().withBinders(Morph.Binder.install(OverrideArgsInvoker.class)).to(each.getInterceptor()));
- } else {
- result = result.method(ElementMatchers.is(each.getDescription())).intercept(MethodDelegation.withDefaultConfiguration().to(each.getInterceptor()));
- }
- // CHECKSTYLE:OFF
- } catch (final Throwable ex) {
- // CHECKSTYLE:ON
- LOGGER.error("Failed to load advice class: {}.", description.getTypeName(), ex);
- }
- }
- return result;
- }
-
- private AgentTransformationPoint<?> getMatchedInstanceMethodPoint(final Collection<InstanceMethodAdvisorConfiguration> instanceMethodAroundPoints,
- final InDefinedShape methodDescription, final ClassLoader classLoader) {
- List<InstanceMethodAdvisorConfiguration> instanceMethodAdvisorConfigs = instanceMethodAroundPoints
- .stream().filter(each -> each.getPointcut().matches(methodDescription)).collect(Collectors.toList());
- if (instanceMethodAdvisorConfigs.isEmpty()) {
- return null;
- }
- if (1 == instanceMethodAdvisorConfigs.size()) {
- return getSingleInstanceMethodPoint(methodDescription, instanceMethodAdvisorConfigs.get(0), classLoader);
- }
- return getComposeInstanceMethodPoint(methodDescription, instanceMethodAdvisorConfigs, classLoader);
- }
-
- private AgentTransformationPoint<?> getSingleInstanceMethodPoint(final InDefinedShape methodDescription,
- final InstanceMethodAdvisorConfiguration instanceMethodAdvisorConfig, final ClassLoader classLoader) {
- InstanceMethodAroundAdvice instanceMethodAroundAdvice = loadAdviceInstance(instanceMethodAdvisorConfig.getAdviceClassName(), classLoader);
- return instanceMethodAdvisorConfig.isOverrideArgs()
- ? new AgentTransformationPoint<>(methodDescription, new InstanceMethodInterceptorArgsOverride(instanceMethodAroundAdvice))
- : new AgentTransformationPoint<>(methodDescription, new InstanceMethodAroundInterceptor(instanceMethodAroundAdvice));
- }
-
- private AgentTransformationPoint<?> getComposeInstanceMethodPoint(final InDefinedShape methodDescription,
- final Collection<InstanceMethodAdvisorConfiguration> instanceMethodAdvisorConfigs, final ClassLoader classLoader) {
- Collection<InstanceMethodAroundAdvice> instanceMethodAroundAdvices = new LinkedList<>();
- boolean isArgsOverride = false;
- for (InstanceMethodAdvisorConfiguration each : instanceMethodAdvisorConfigs) {
- if (each.isOverrideArgs()) {
- isArgsOverride = true;
- }
- if (null != each.getAdviceClassName()) {
- instanceMethodAroundAdvices.add(loadAdviceInstance(each.getAdviceClassName(), classLoader));
- }
- }
- return isArgsOverride
- ? new AgentTransformationPoint<>(methodDescription, new ComposedInstanceMethodInterceptorArgsOverride(instanceMethodAroundAdvices))
- : new AgentTransformationPoint<>(methodDescription, new ComposedInstanceMethodAroundInterceptor(instanceMethodAroundAdvices));
- }
-
- private <T> T loadAdviceInstance(final String adviceClassName, final ClassLoader classLoader) {
- return AdviceInstanceLoader.loadAdviceInstance(adviceClassName, classLoader, pluginConfigs, isEnhancedForProxy);
- }
}
diff --git a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformationPoint.java b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/MethodAdvisor.java
similarity index 86%
rename from agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformationPoint.java
rename to agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/MethodAdvisor.java
index 9ae4eb0c2e9..81733a407e1 100644
--- a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/AgentTransformationPoint.java
+++ b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/MethodAdvisor.java
@@ -22,13 +22,13 @@ import lombok.RequiredArgsConstructor;
import net.bytebuddy.description.method.MethodDescription;
/**
- * Agent transformer point.
+ * Method advisor.
*/
@RequiredArgsConstructor
@Getter
-public final class AgentTransformationPoint<T> {
+public final class MethodAdvisor<T> {
- private final MethodDescription description;
+ private final MethodDescription pointcut;
- private final T interceptor;
+ private final T advice;
}
diff --git a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/ConstructorAdvisorBuilder.java b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/ConstructorAdvisorBuilder.java
new file mode 100644
index 00000000000..ab2bf1c0b7a
--- /dev/null
+++ b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/ConstructorAdvisorBuilder.java
@@ -0,0 +1,107 @@
+/*
+ * 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.shardingsphere.agent.core.transformer.builder;
+
+import lombok.RequiredArgsConstructor;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.method.MethodDescription.InDefinedShape;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.DynamicType.Builder;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.implementation.SuperMethodCall;
+import net.bytebuddy.matcher.ElementMatchers;
+import org.apache.shardingsphere.agent.config.advisor.ConstructorAdvisorConfiguration;
+import org.apache.shardingsphere.agent.config.plugin.PluginConfiguration;
+import org.apache.shardingsphere.agent.core.logging.LoggerFactory;
+import org.apache.shardingsphere.agent.core.plugin.advice.ConstructorAdvice;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.ConstructorInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedConstructorInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.loader.AdviceInstanceLoader;
+import org.apache.shardingsphere.agent.core.transformer.MethodAdvisor;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Constructor advisor builder.
+ */
+@RequiredArgsConstructor
+public final class ConstructorAdvisorBuilder {
+
+ private static final LoggerFactory.Logger LOGGER = LoggerFactory.getLogger(ConstructorAdvisorBuilder.class);
+
+ private final Map<String, PluginConfiguration> pluginConfigs;
+
+ private final Collection<ConstructorAdvisorConfiguration> constructorAdvisorConfigs;
+
+ private final boolean isEnhancedForProxy;
+
+ private final TypeDescription typePointcut;
+
+ private final ClassLoader classLoader;
+
+ /**
+ * Create constructor advisor builder.
+ *
+ * @param builder original builder
+ * @return created builder
+ */
+ public Builder<?> create(final Builder<?> builder) {
+ Builder<?> result = builder;
+ Collection<MethodAdvisor<? extends ConstructorInterceptor>> constructorAdvisors = typePointcut.getDeclaredMethods().stream()
+ .filter(MethodDescription::isConstructor)
+ .map(this::getMatchedConstructorAdvisor)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ for (MethodAdvisor<? extends ConstructorInterceptor> each : constructorAdvisors) {
+ try {
+ result = result.constructor(ElementMatchers.is(each.getPointcut()))
+ .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration().to(each.getAdvice())));
+ // CHECKSTYLE:OFF
+ } catch (final Throwable ex) {
+ // CHECKSTYLE:ON
+ LOGGER.error("Failed to load advice class: {}.", typePointcut.getTypeName(), ex);
+ }
+ }
+ return result;
+ }
+
+ private MethodAdvisor<? extends ConstructorInterceptor> getMatchedConstructorAdvisor(final InDefinedShape methodPointcut) {
+ List<ConstructorAdvisorConfiguration> matchedConstructorAdvisorConfigs = constructorAdvisorConfigs
+ .stream().filter(each -> each.getPointcut().matches(methodPointcut)).collect(Collectors.toList());
+ if (matchedConstructorAdvisorConfigs.isEmpty()) {
+ return null;
+ }
+ if (1 == matchedConstructorAdvisorConfigs.size()) {
+ return new MethodAdvisor<>(
+ methodPointcut, new ConstructorInterceptor(loadAdviceInstance(matchedConstructorAdvisorConfigs.get(0).getAdviceClassName())));
+ }
+ Collection<ConstructorAdvice> constructorAdvices = matchedConstructorAdvisorConfigs.stream()
+ .map(ConstructorAdvisorConfiguration::getAdviceClassName)
+ .map(each -> (ConstructorAdvice) loadAdviceInstance(each))
+ .collect(Collectors.toList());
+ return new MethodAdvisor<>(methodPointcut, new ComposedConstructorInterceptor(constructorAdvices));
+ }
+
+ private <T> T loadAdviceInstance(final String adviceClassName) {
+ return AdviceInstanceLoader.loadAdviceInstance(adviceClassName, classLoader, pluginConfigs, isEnhancedForProxy);
+ }
+}
diff --git a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/InstanceMethodAdvisorBuilder.java b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/InstanceMethodAdvisorBuilder.java
new file mode 100644
index 00000000000..9f753b71507
--- /dev/null
+++ b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/InstanceMethodAdvisorBuilder.java
@@ -0,0 +1,132 @@
+/*
+ * 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.shardingsphere.agent.core.transformer.builder;
+
+import lombok.RequiredArgsConstructor;
+import net.bytebuddy.description.method.MethodDescription.InDefinedShape;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.DynamicType.Builder;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.implementation.bind.annotation.Morph;
+import net.bytebuddy.matcher.ElementMatchers;
+import org.apache.shardingsphere.agent.config.advisor.InstanceMethodAdvisorConfiguration;
+import org.apache.shardingsphere.agent.config.plugin.PluginConfiguration;
+import org.apache.shardingsphere.agent.core.logging.LoggerFactory;
+import org.apache.shardingsphere.agent.core.plugin.OverrideArgsInvoker;
+import org.apache.shardingsphere.agent.core.plugin.advice.InstanceMethodAroundAdvice;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.InstanceMethodAroundInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.InstanceMethodInterceptorArgsOverride;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedInstanceMethodAroundInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedInstanceMethodInterceptorArgsOverride;
+import org.apache.shardingsphere.agent.core.plugin.loader.AdviceInstanceLoader;
+import org.apache.shardingsphere.agent.core.transformer.MethodAdvisor;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Instance method advisor builder.
+ */
+@RequiredArgsConstructor
+public final class InstanceMethodAdvisorBuilder {
+
+ private static final LoggerFactory.Logger LOGGER = LoggerFactory.getLogger(InstanceMethodAdvisorBuilder.class);
+
+ private final Map<String, PluginConfiguration> pluginConfigs;
+
+ private final Collection<InstanceMethodAdvisorConfiguration> instanceMethodAdvisorConfigs;
+
+ private final boolean isEnhancedForProxy;
+
+ private final TypeDescription typePointcut;
+
+ private final ClassLoader classLoader;
+
+ /**
+ * Create instance method advisor builder.
+ *
+ * @param builder original builder
+ * @return created builder
+ */
+ public Builder<?> create(final Builder<?> builder) {
+ Collection<MethodAdvisor<?>> instanceMethodAdviceComposePoints = typePointcut.getDeclaredMethods().stream()
+ .filter(each -> !(each.isAbstract() || each.isSynthetic()))
+ .map(this::getMatchedInstanceMethodPoint)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ Builder<?> result = builder;
+ for (MethodAdvisor<?> each : instanceMethodAdviceComposePoints) {
+ try {
+ if (each.getAdvice() instanceof InstanceMethodInterceptorArgsOverride) {
+ result = result.method(ElementMatchers.is(each.getPointcut()))
+ .intercept(MethodDelegation.withDefaultConfiguration().withBinders(Morph.Binder.install(OverrideArgsInvoker.class)).to(each.getAdvice()));
+ } else {
+ result = result.method(ElementMatchers.is(each.getPointcut())).intercept(MethodDelegation.withDefaultConfiguration().to(each.getAdvice()));
+ }
+ // CHECKSTYLE:OFF
+ } catch (final Throwable ex) {
+ // CHECKSTYLE:ON
+ LOGGER.error("Failed to load advice class: {}.", typePointcut.getTypeName(), ex);
+ }
+ }
+ return result;
+ }
+
+ private MethodAdvisor<?> getMatchedInstanceMethodPoint(final InDefinedShape methodPointcut) {
+ List<InstanceMethodAdvisorConfiguration> instanceMethodAdvisorConfigs = this.instanceMethodAdvisorConfigs
+ .stream().filter(each -> each.getPointcut().matches(methodPointcut)).collect(Collectors.toList());
+ if (instanceMethodAdvisorConfigs.isEmpty()) {
+ return null;
+ }
+ if (1 == instanceMethodAdvisorConfigs.size()) {
+ return getSingleInstanceMethodPoint(methodPointcut, instanceMethodAdvisorConfigs.get(0));
+ }
+ return getComposeInstanceMethodPoint(methodPointcut);
+ }
+
+ private MethodAdvisor<?> getSingleInstanceMethodPoint(final InDefinedShape methodPointcut, final InstanceMethodAdvisorConfiguration instanceMethodAdvisorConfig) {
+ InstanceMethodAroundAdvice instanceMethodAroundAdvice = loadAdviceInstance(instanceMethodAdvisorConfig.getAdviceClassName());
+ return instanceMethodAdvisorConfig.isOverrideArgs()
+ ? new MethodAdvisor<>(methodPointcut, new InstanceMethodInterceptorArgsOverride(instanceMethodAroundAdvice))
+ : new MethodAdvisor<>(methodPointcut, new InstanceMethodAroundInterceptor(instanceMethodAroundAdvice));
+ }
+
+ private MethodAdvisor<?> getComposeInstanceMethodPoint(final InDefinedShape methodPointcut) {
+ Collection<InstanceMethodAroundAdvice> instanceMethodAroundAdvices = new LinkedList<>();
+ boolean isArgsOverride = false;
+ for (InstanceMethodAdvisorConfiguration each : instanceMethodAdvisorConfigs) {
+ if (each.isOverrideArgs()) {
+ isArgsOverride = true;
+ }
+ if (null != each.getAdviceClassName()) {
+ instanceMethodAroundAdvices.add(loadAdviceInstance(each.getAdviceClassName()));
+ }
+ }
+ return isArgsOverride
+ ? new MethodAdvisor<>(methodPointcut, new ComposedInstanceMethodInterceptorArgsOverride(instanceMethodAroundAdvices))
+ : new MethodAdvisor<>(methodPointcut, new ComposedInstanceMethodAroundInterceptor(instanceMethodAroundAdvices));
+ }
+
+ private <T> T loadAdviceInstance(final String adviceClassName) {
+ return AdviceInstanceLoader.loadAdviceInstance(adviceClassName, classLoader, pluginConfigs, isEnhancedForProxy);
+ }
+}
diff --git a/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/StaticMethodAdvisorBuilder.java b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/StaticMethodAdvisorBuilder.java
new file mode 100644
index 00000000000..7e5e495dd60
--- /dev/null
+++ b/agent/core/src/main/java/org/apache/shardingsphere/agent/core/transformer/builder/StaticMethodAdvisorBuilder.java
@@ -0,0 +1,130 @@
+/*
+ * 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.shardingsphere.agent.core.transformer.builder;
+
+import lombok.RequiredArgsConstructor;
+import net.bytebuddy.description.method.MethodDescription.InDefinedShape;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.DynamicType.Builder;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.implementation.bind.annotation.Morph;
+import net.bytebuddy.matcher.ElementMatchers;
+import org.apache.shardingsphere.agent.config.advisor.StaticMethodAdvisorConfiguration;
+import org.apache.shardingsphere.agent.config.plugin.PluginConfiguration;
+import org.apache.shardingsphere.agent.core.logging.LoggerFactory;
+import org.apache.shardingsphere.agent.core.plugin.OverrideArgsInvoker;
+import org.apache.shardingsphere.agent.core.plugin.advice.StaticMethodAroundAdvice;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.StaticMethodAroundInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.StaticMethodInterceptorArgsOverride;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedStaticMethodAroundInterceptor;
+import org.apache.shardingsphere.agent.core.plugin.interceptor.composed.ComposedStaticMethodInterceptorArgsOverride;
+import org.apache.shardingsphere.agent.core.plugin.loader.AdviceInstanceLoader;
+import org.apache.shardingsphere.agent.core.transformer.MethodAdvisor;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Static method advisor builder.
+ */
+@RequiredArgsConstructor
+public final class StaticMethodAdvisorBuilder {
+
+ private static final LoggerFactory.Logger LOGGER = LoggerFactory.getLogger(StaticMethodAdvisorBuilder.class);
+
+ private final Map<String, PluginConfiguration> pluginConfigs;
+
+ private final Collection<StaticMethodAdvisorConfiguration> staticMethodAdvisorConfigs;
+
+ private final boolean isEnhancedForProxy;
+
+ private final TypeDescription typePointcut;
+
+ private final ClassLoader classLoader;
+
+ /**
+ * Create static method advisor builder.
+ *
+ * @param builder original builder
+ * @return created builder
+ */
+ public Builder<?> create(final Builder<?> builder) {
+ Collection<MethodAdvisor<?>> staticMethodAdvicePoints = typePointcut.getDeclaredMethods().stream()
+ .filter(each -> each.isStatic() && !(each.isAbstract() || each.isSynthetic()))
+ .map(this::getMatchedStaticMethodPoint)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ Builder<?> result = builder;
+ for (MethodAdvisor<?> each : staticMethodAdvicePoints) {
+ try {
+ if (each.getAdvice() instanceof StaticMethodInterceptorArgsOverride) {
+ result = result.method(ElementMatchers.is(each.getPointcut()))
+ .intercept(MethodDelegation.withDefaultConfiguration().withBinders(Morph.Binder.install(OverrideArgsInvoker.class)).to(each.getAdvice()));
+ } else {
+ result = result.method(ElementMatchers.is(each.getPointcut())).intercept(MethodDelegation.withDefaultConfiguration().to(each.getAdvice()));
+ }
+ // CHECKSTYLE:OFF
+ } catch (final Throwable ex) {
+ // CHECKSTYLE:ON
+ LOGGER.error("Failed to load advice class: {}.", typePointcut.getTypeName(), ex);
+ }
+ }
+ return result;
+ }
+
+ private MethodAdvisor<?> getMatchedStaticMethodPoint(final InDefinedShape methodPointcut) {
+ List<StaticMethodAdvisorConfiguration> matchedAdvisors = staticMethodAdvisorConfigs.stream().filter(each -> each.getPointcut().matches(methodPointcut)).collect(Collectors.toList());
+ if (matchedAdvisors.isEmpty()) {
+ return null;
+ }
+ if (1 == matchedAdvisors.size()) {
+ return getSingleStaticMethodPoint(methodPointcut, matchedAdvisors.get(0));
+ }
+ return getComposedStaticMethodPoint(methodPointcut);
+ }
+
+ private MethodAdvisor<?> getSingleStaticMethodPoint(final InDefinedShape methodPointcut, final StaticMethodAdvisorConfiguration staticMethodAdvisorConfig) {
+ StaticMethodAroundAdvice staticMethodAroundAdvice = loadAdviceInstance(staticMethodAdvisorConfig.getAdviceClassName());
+ return staticMethodAdvisorConfig.isOverrideArgs()
+ ? new MethodAdvisor<>(methodPointcut, new StaticMethodInterceptorArgsOverride(staticMethodAroundAdvice))
+ : new MethodAdvisor<>(methodPointcut, new StaticMethodAroundInterceptor(staticMethodAroundAdvice));
+ }
+
+ private MethodAdvisor<?> getComposedStaticMethodPoint(final InDefinedShape methodPointcut) {
+ Collection<StaticMethodAroundAdvice> staticMethodAroundAdvices = new LinkedList<>();
+ boolean isArgsOverride = false;
+ for (StaticMethodAdvisorConfiguration each : staticMethodAdvisorConfigs) {
+ if (each.isOverrideArgs()) {
+ isArgsOverride = true;
+ }
+ if (null != each.getAdviceClassName()) {
+ staticMethodAroundAdvices.add(loadAdviceInstance(each.getAdviceClassName()));
+ }
+ }
+ return isArgsOverride ? new MethodAdvisor<>(methodPointcut, new ComposedStaticMethodInterceptorArgsOverride(staticMethodAroundAdvices))
+ : new MethodAdvisor<>(methodPointcut, new ComposedStaticMethodAroundInterceptor(staticMethodAroundAdvices));
+ }
+
+ private <T> T loadAdviceInstance(final String adviceClassName) {
+ return AdviceInstanceLoader.loadAdviceInstance(adviceClassName, classLoader, pluginConfigs, isEnhancedForProxy);
+ }
+}