6 | * // original class
7 | * public class Foo {
8 | * public void sayHello() {
9 | * System.out.println("Hello Advice);
10 | * }
11 | * }
12 | *
13 | * // advice class
14 | * public class FooAdvice {
15 | * public void enterMethod(ExecuteContext context) {
16 | * System.err.println("Hello Enter Method.");
17 | * }
18 | *
19 | * public void exitMethod(ExecuteContext context) {
20 | * System.err.println("Hello Exit Method.);
21 | * }
22 | * }
23 | *
24 | * // Foo final pseudocode class
25 | * public class Foo {
26 | * public void sayHello() {
27 | * System.err.println("Hello Enter Method.");
28 | * System.out.println("Hello Advice);
29 | * System.err.println("Hello Exit Method.);
30 | * }
31 | * }
32 | *
33 | *
34 | * @author duoliang.zhang
35 | * @since 2020/8/22 11:25
36 | */
37 | public interface Advice extends Named, LifeCycle, Switchable {
38 |
39 | static io.manbang.gravity.plugin.Advice of(Class adviceClass) {
40 | return AdviceHolder.getOrCreate(adviceClass);
41 | }
42 |
43 | /**
44 | * 方法体前执行逻辑，如果想提前终止业务方法执行的话，可以执行 {@link ExecuteContext#skip()}
45 | * 想要改变返回值的话，在 {@link #exitMethod(ExecuteContext)} 中设置自定义的返回值
46 | *
47 | * @param context 执行上下文
48 | */
49 | default void enterMethod(ExecuteContext context) {
50 | }
51 |
52 | /**
53 | * 方法提后逻辑
54 | *
55 | * @param context 执行上下文
56 | */
57 | default void exitMethod(ExecuteContext context) {
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/AdviceHolder.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import java.util.Map;
4 | import java.util.concurrent.ConcurrentHashMap;
5 |
6 | /**
7 | * @author duoliang.zhang
8 | * @since 2021/8/26 15:02
9 | */
10 | class AdviceHolder {
11 | private static final Map
22 | * public class TimingAdvice implements Advice {
23 | * public static final class Template {
24 | * // Advice Template 中的代码
25 | * }
26 | *
27 | * // enterMethod 逻辑
28 | * // exitMethod 逻辑
29 | * }
30 | *
31 | *
32 | * @author duoliang.zhang
33 | * @since 2020/8/26 9:36
34 | */
35 | public class AdviceTemplate {
36 | public static final String WITH_THROWABLE_TEMPLATE = "io.manbang.gravity.plugin.AdviceTemplate$WithThrowableTemplate";
37 | public static final String WITH_METHOD_TEMPLATE = "io.manbang.gravity.plugin.AdviceTemplate$WithMethodTemplate";
38 | public static final String WITH_CONSTRUCTOR_TEMPLATE = "io.manbang.gravity.plugin.AdviceTemplate$WithConstructorTemplate";
39 | public static final String MINI_TEMPLATE = "io.manbang.gravity.plugin.AdviceTemplate$MiniTemplate";
40 | public static final String FULL_TEMPLATE = "io.manbang.gravity.plugin.AdviceTemplate$FullTemplate";
41 | public static final Logger LOGGER = Logger.getLogger(ADVICE_LOGGER_NAME);
42 |
43 | private AdviceTemplate() {
44 | throw new UnsupportedOperationException();
45 | }
46 |
47 | public static ExecuteContext getContext(Class targetClass, Object target, Method method, Object[] arguments, Constructor constructor, ExtendedExecutor extendedExecutor) {
48 | return ExecuteContext.builder()
49 | .targetClass(targetClass)
50 | .target(target)
51 | .method(method)
52 | .arguments(arguments)
53 | .constructor(constructor)
54 | .extraExecutor(extendedExecutor)
55 | .build();
56 | }
57 |
58 | public static class MiniTemplate {
59 | private static io.manbang.gravity.plugin.Advice advice;
60 | private static ExtendedExecutor extendedExecutor;
61 |
62 | private MiniTemplate() {
63 | throw new UnsupportedOperationException();
64 | }
65 |
66 | public static io.manbang.gravity.plugin.Advice getAdvice() {
67 | return advice;
68 | }
69 |
70 | public static void setAdvice(io.manbang.gravity.plugin.Advice advice) {
71 | MiniTemplate.advice = advice;
72 | }
73 |
74 | public static ExtendedExecutor getExtendedExecutor() {
75 | return extendedExecutor;
76 | }
77 |
78 | public static void setExtendedExecutor(ExtendedExecutor extendedExecutor) {
79 | MiniTemplate.extendedExecutor = extendedExecutor;
80 | }
81 |
82 | @Advice.OnMethodEnter
83 | public static ExecuteContext enterMethod(@Advice.Origin Class targetClass,
84 | @Advice.This(optional = true) Object target,
85 | @Advice.AllArguments(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object[] arguments) {
86 | ExecuteContext context = getContext(targetClass, target, null, arguments, null, getExtendedExecutor());
87 | try {
88 | getAdvice().enterMethod(context);
89 | arguments = context.getArguments();
90 | } catch (Throwable e) {
91 | LOGGER.log(Level.WARNING, ENTER_METHOD_ERROR, e);
92 | }
93 | return context;
94 | }
95 |
96 | @Advice.OnMethodExit
97 | public static void exitMethod(@Advice.Enter ExecuteContext context,
98 | @Advice.This(optional = true) Object target,
99 | @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object result) {
100 | context.setTarget(target);
101 | context.setResult(result);
102 |
103 | try {
104 | getAdvice().exitMethod(context);
105 | result = context.getResult();
106 | } catch (Throwable e) {
107 | LOGGER.log(Level.WARNING, EXIT_METHOD_ERROR, e);
108 | }
109 | }
110 | }
111 |
112 | public static class WithMethodTemplate {
113 | private static io.manbang.gravity.plugin.Advice advice;
114 | private static ExtendedExecutor extendedExecutor;
115 |
116 | private WithMethodTemplate() {
117 | throw new UnsupportedOperationException();
118 | }
119 |
120 | public static io.manbang.gravity.plugin.Advice getAdvice() {
121 | return advice;
122 | }
123 |
124 | public static void setAdvice(io.manbang.gravity.plugin.Advice advice) {
125 | WithMethodTemplate.advice = advice;
126 | }
127 |
128 | public static ExtendedExecutor getExtendedExecutor() {
129 | return extendedExecutor;
130 | }
131 |
132 | public static void setExtendedExecutor(ExtendedExecutor extendedExecutor) {
133 | WithMethodTemplate.extendedExecutor = extendedExecutor;
134 | }
135 |
136 | @Advice.OnMethodEnter
137 | public static ExecuteContext enterMethod(@Advice.Origin Class targetClass,
138 | @Advice.This(optional = true) Object target,
139 | @Advice.Origin Method method,
140 | @Advice.AllArguments(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object[] arguments) {
141 | ExecuteContext context = getContext(targetClass, target, method, arguments, null, getExtendedExecutor());
142 | try {
143 | getAdvice().enterMethod(context);
144 | arguments = context.getArguments();
145 | } catch (Throwable e) {
146 | LOGGER.log(Level.WARNING, ENTER_METHOD_ERROR, e);
147 | }
148 | return context;
149 | }
150 |
151 | @Advice.OnMethodExit
152 | public static void exitMethod(@Advice.Enter ExecuteContext context,
153 | @Advice.This(optional = true) Object target,
154 | @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object result) {
155 | context.setTarget(target);
156 | context.setResult(result);
157 |
158 | try {
159 | getAdvice().exitMethod(context);
160 | result = context.getResult();
161 | } catch (Throwable e) {
162 | LOGGER.log(Level.WARNING, EXIT_METHOD_ERROR, e);
163 | }
164 | }
165 | }
166 |
167 | public static class WithConstructorTemplate {
168 | private static io.manbang.gravity.plugin.Advice advice;
169 | private static ExtendedExecutor extendedExecutor;
170 |
171 | private WithConstructorTemplate() {
172 | throw new UnsupportedOperationException();
173 | }
174 |
175 | public static io.manbang.gravity.plugin.Advice getAdvice() {
176 | return advice;
177 | }
178 |
179 | public static void setAdvice(io.manbang.gravity.plugin.Advice advice) {
180 | WithConstructorTemplate.advice = advice;
181 | }
182 |
183 | public static ExtendedExecutor getExtendedExecutor() {
184 | return extendedExecutor;
185 | }
186 |
187 | public static void setExtendedExecutor(ExtendedExecutor extendedExecutor) {
188 | WithConstructorTemplate.extendedExecutor = extendedExecutor;
189 | }
190 |
191 | @Advice.OnMethodEnter
192 | public static ExecuteContext enterMethod(@Advice.Origin Class targetClass,
193 | @Advice.This(optional = true) Object target,
194 | @Advice.Origin Constructor constructor,
195 | @Advice.AllArguments(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object[] arguments) {
196 | ExecuteContext context = getContext(targetClass, target, null, arguments, constructor, getExtendedExecutor());
197 | try {
198 | getAdvice().enterMethod(context);
199 | arguments = context.getArguments();
200 | } catch (Throwable e) {
201 | LOGGER.log(Level.WARNING, ENTER_METHOD_ERROR, e);
202 | }
203 | return context;
204 | }
205 |
206 | @Advice.OnMethodExit
207 | public static void exitMethod(@Advice.Enter ExecuteContext context,
208 | @Advice.This(optional = true) Object target,
209 | @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object result) {
210 | context.setTarget(target);
211 | context.setResult(result);
212 |
213 | try {
214 | getAdvice().exitMethod(context);
215 | result = context.getResult();
216 | } catch (Throwable e) {
217 | LOGGER.log(Level.WARNING, EXIT_METHOD_ERROR, e);
218 | }
219 | }
220 | }
221 |
222 | public static class WithThrowableTemplate {
223 | private static io.manbang.gravity.plugin.Advice advice;
224 | private static ExtendedExecutor extendedExecutor;
225 |
226 | private WithThrowableTemplate() {
227 | throw new UnsupportedOperationException();
228 | }
229 |
230 | public static io.manbang.gravity.plugin.Advice getAdvice() {
231 | return advice;
232 | }
233 |
234 | public static void setAdvice(io.manbang.gravity.plugin.Advice advice) {
235 | WithThrowableTemplate.advice = advice;
236 | }
237 |
238 | public static ExtendedExecutor getExtendedExecutor() {
239 | return extendedExecutor;
240 | }
241 |
242 | public static void setExtendedExecutor(ExtendedExecutor extendedExecutor) {
243 | WithThrowableTemplate.extendedExecutor = extendedExecutor;
244 | }
245 |
246 | @Advice.OnMethodEnter
247 | public static ExecuteContext enterMethod(@Advice.Origin Class targetClass,
248 | @Advice.This(optional = true) Object target,
249 | @Advice.AllArguments(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object[] arguments) {
250 | ExecuteContext context = getContext(targetClass, target, null, arguments, null, getExtendedExecutor());
251 | try {
252 | getAdvice().enterMethod(context);
253 | arguments = context.getArguments();
254 | } catch (Throwable e) {
255 | LOGGER.log(Level.WARNING, ENTER_METHOD_ERROR, e);
256 | }
257 | return context;
258 | }
259 |
260 | @Advice.OnMethodExit(onThrowable = Throwable.class)
261 | public static void exitMethod(@Advice.Enter ExecuteContext context,
262 | @Advice.This(optional = true) Object target,
263 | @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object result,
264 | @Advice.Thrown(readOnly = false) Throwable throwable) {
265 | context.setTarget(target);
266 | context.setResult(result);
267 | context.setThrowable(throwable);
268 |
269 | try {
270 | getAdvice().exitMethod(context);
271 | result = context.getResult();
272 | throwable = context.getThrowable();
273 | } catch (Throwable e) {
274 | LOGGER.log(Level.WARNING, EXIT_METHOD_ERROR, e);
275 | }
276 | }
277 | }
278 |
279 | public static class FullTemplate {
280 | private static io.manbang.gravity.plugin.Advice advice;
281 | private static ExtendedExecutor extendedExecutor;
282 |
283 | private FullTemplate() {
284 | throw new UnsupportedOperationException();
285 | }
286 |
287 | public static io.manbang.gravity.plugin.Advice getAdvice() {
288 | return advice;
289 | }
290 |
291 | public static void setAdvice(io.manbang.gravity.plugin.Advice advice) {
292 | FullTemplate.advice = advice;
293 | }
294 |
295 | public static ExtendedExecutor getExtendedExecutor() {
296 | return extendedExecutor;
297 | }
298 |
299 | public static void setExtendedExecutor(ExtendedExecutor extendedExecutor) {
300 | FullTemplate.extendedExecutor = extendedExecutor;
301 | }
302 |
303 | @Advice.OnMethodEnter
304 | public static ExecuteContext enterMethod(@Advice.Origin Class targetClass,
305 | @Advice.This(optional = true) Object target,
306 | @Advice.Origin Method method,
307 | @Advice.AllArguments(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object[] arguments) {
308 | ExecuteContext context = getContext(targetClass, target, method, arguments, null, getExtendedExecutor());
309 | try {
310 | getAdvice().enterMethod(context);
311 | arguments = context.getArguments();
312 | } catch (Throwable e) {
313 | LOGGER.log(Level.WARNING, ENTER_METHOD_ERROR, e);
314 | }
315 | return context;
316 | }
317 |
318 | @Advice.OnMethodExit(onThrowable = Throwable.class)
319 | public static void exitMethod(@Advice.Enter ExecuteContext context,
320 | @Advice.This(optional = true) Object target,
321 | @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object result,
322 | @Advice.Thrown(readOnly = false) Throwable throwable) {
323 | context.setTarget(target);
324 | context.setResult(result);
325 | context.setThrowable(throwable);
326 |
327 | try {
328 | getAdvice().exitMethod(context);
329 | result = context.getResult();
330 | throwable = context.getThrowable();
331 | } catch (Throwable e) {
332 | LOGGER.log(Level.WARNING, EXIT_METHOD_ERROR, e);
333 | }
334 | }
335 | }
336 | }
337 |
338 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/AgentBuilderCustomizer.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 |
4 | import net.bytebuddy.agent.builder.AgentBuilder;
5 |
6 | /**
7 | * 代理构建器定制器SPI，用户可以自定义，如果没有自定义需求，则利用默认定制器 {@link DefaultAgentBuilderCustomizer}
8 | *
9 | * @author 章多亮
10 | * @since 2020-08-07
11 | */
12 | public interface AgentBuilderCustomizer {
13 | /**
14 | * 当没有用户自定义的定制器时，用默认的定制器
15 | *
16 | * @param pluginClassLoader 插件加载器
17 | * @return 代理构建定制器
18 | */
19 | static AgentBuilderCustomizer customizer(AgentPluginClassLoader pluginClassLoader) {
20 | return Services.loadFirst(AgentBuilderCustomizer.class, pluginClassLoader, DefaultAgentBuilderCustomizer.INSTANCE);
21 | }
22 |
23 | /**
24 | * 用户自定义代理构建器
25 | *
26 | * @param options Agent入参
27 | * @param builder 代理构建器
28 | * @return 配置后的代理构建器
29 | */
30 | AgentBuilder customize(final AgentOptions options, final AgentBuilder builder);
31 | }
32 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/AgentOptions.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import java.util.Collections;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 |
7 | /**
8 | * 代理配置选项
9 | *
10 | * @author dzhang
11 | * @since 2020/08/18
12 | */
13 | public enum AgentOptions {
14 | /**
15 | * instance
16 | */
17 | INSTANCE;
18 |
19 | private final String argument;
20 | private final Maptrue，否则，返回false
138 | */
139 | public boolean isSkipped() {
140 | return skipped;
141 | }
142 |
143 | public void setSkipped(boolean skipped) {
144 | this.skipped = skipped;
145 | }
146 |
147 | /**
148 | * 跳过业务逻辑执行
149 | */
150 | public void skip() {
151 | this.skipped = true;
152 | }
153 |
154 | /**
155 | * 获取被拦截对象的全限定名
156 | *
157 | * @return 被拦截类的全限定名
158 | */
159 | public String getTargetClassName() {
160 | return targetClass.getName();
161 | }
162 |
163 | public ClassLoader getClassLoader() {
164 | return targetClass.getClassLoader();
165 | }
166 |
167 | /**
168 | * 设置新的异常实例
169 | *
170 | * @param throwable 新异常
171 | */
172 | public void newThrowable(Throwable throwable) {
173 | this.throwable = throwable;
174 | }
175 |
176 | /**
177 | * 这是新的返回值，改变原方法的返回值
178 | *
179 | * @param result 返回值
180 | */
181 | public void newResult(Object result) {
182 | this.result = result;
183 | this.throwable = null;
184 | }
185 |
186 | /**
187 | * 获取附件列表，不能修改
188 | *
189 | * @return 附件列表
190 | */
191 | public Mapnull
394 | *
395 | * @param target 被植入对象
396 | */
397 | public void setTarget(Object target) {
398 | this.target = target;
399 | }
400 |
401 | public true，然后继续执行 start 方法，此接口，不允许抛出异常
11 | *
12 | * @param classLoader 当前应用的类加载器
13 | * @return 如果，继续执行 start 接口，则返回true，否则，精灵服务将不会执行
14 | */
15 | default boolean prepare(ClassLoader classLoader) {
16 | return true;
17 | }
18 |
19 | /**
20 | * 启动服务
21 | */
22 | void start();
23 |
24 | /**
25 | * 停止服务，如果需要清理资源，请覆盖此接口，默认什么都不干
26 | */
27 | default void stop() {
28 | //
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/GravityUtils.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import lombok.extern.java.Log;
4 |
5 | import java.io.ByteArrayOutputStream;
6 | import java.io.IOException;
7 | import java.io.InputStream;
8 | import java.io.PrintWriter;
9 | import java.io.StringWriter;
10 | import java.lang.instrument.Instrumentation;
11 | import java.net.MalformedURLException;
12 | import java.net.URI;
13 | import java.net.URL;
14 | import java.util.Collections;
15 | import java.util.HashMap;
16 | import java.util.Map;
17 | import java.util.concurrent.atomic.AtomicReference;
18 |
19 | /**
20 | * @author dzhang
21 | */
22 | @Log
23 | public class GravityUtils {
24 | private static final Map
6 | * // original class
7 | * public class Foo {
8 | * public String sayHello() {
9 | * return "Hello Interceptor.";
10 | * }
11 | * }
12 | *
13 | * // interceptor class
14 | * public FooInterceptor implements Interceptor {
15 | * public boolean beforeMethod(ExecuteContext context) {
16 | * System.err.println("Hello Before Method.");
17 | * return true;
18 | * }
19 | *
20 | * public void handleException(ExecuteContext context) {
21 | * System.err.println("Hello Handle Exception.");
22 | * }
23 | *
24 | * public void afterMethod(ExecuteContext context) {
25 | * System.err.println("Hello After Method.");
26 | * }
27 | *
28 | * public void onCompleted(ExecuteContext context) {
29 | * System.err.println("Hello on Completed.);
30 | * }
31 | * }
32 | *
33 | * // Foo final pseudocode class
34 | * public class Foo {
35 | * public String sayHello() {
36 | * // ......
37 | * ExecuteContext context = getContext();
38 | * boolean continued = interceptor.beforeMethod(context);
39 | * if (continued) {
40 | * try {
41 | * String result = sayHelloWrapped();
42 | * context.setResult(result);
43 | * interceptor.afterMethod(context);
44 | * } catch(Throwable throwable) {
45 | * context.setThrowable(throwable);
46 | * interceptor.handleException(context);
47 | * } finally {
48 | * interceptor.onCompleted(context);
49 | * }
50 | * }
51 | *
52 | * if (context.isRethrown()) {
53 | * throw context.getThrowable();
54 | * }
55 | *
56 | * return context.getResult();
57 | * }
58 | *
59 | * private String sayHelloWrapped() {
60 | * return "Hello Interceptor.";
61 | * }
62 | * }
63 | *
64 | *
65 | * @author duoliang.zhang
66 | * @since 2020/8/22 11:27
67 | */
68 | public interface Interceptor extends Named, LifeCycle, Switchable {
69 |
70 | /**
71 | * 将原始 {@link Interceptor} 做一次包装，如果 {@link Interceptor} 支持开关的话，会封装成 {@link SwitcherInterceptor}，否则直接返回
72 | *
73 | * @param interceptor 拦截器插件
74 | * @return 如果是可以开关控制的 {@link Interceptor}，返回包装后的 {@link SwitcherInterceptor}
75 | */
76 | static Interceptor switcher(Interceptor interceptor) {
77 | return interceptor.isSwitchable() ? new SwitcherInterceptor(interceptor) : interceptor;
78 | }
79 |
80 | /**
81 | * 原方法执行前，回调，可以通过 {@link ExecuteContext#setResult(Object)} 设置新的返回值
82 | *
83 | * @param context 执行上下文
84 | * @return 如果继续希望继续执行，返回true，否则，原方法不再执行
85 | */
86 | default boolean beforeMethod(ExecuteContext context) {
87 | return true;
88 | }
89 |
90 | /**
91 | * 如果原方法执行异常，回调此方法处理，{@link ExecuteContext#getThrowable()} 获取异常信息，默认直接抛出异常
92 | *
93 | * @param context 执行上下文
94 | */
95 | default void handleException(ExecuteContext context) throws Throwable {
96 | if (context.getThrowable() != null) {
97 | throw context.getThrowable();
98 | }
99 | }
100 |
101 | /**
102 | * 远方执行之后，回调，
103 | *
104 | * @param context 执行上下文
105 | */
106 | default void afterMethod(ExecuteContext context) {
107 |
108 | }
109 |
110 | /**
111 | * @param context 执行上下文
112 | */
113 | default void onCompleted(ExecuteContext context) {
114 |
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/InterceptorFactory.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | /**
4 | * @author weilong.hu
5 | * @since 2022/01/22 14:08
6 | */
7 | public interface InterceptorFactory {
8 | /**
9 | * 拦截方法 支持静态和实例方法
10 | *
11 | * @param interceptor 拦截器
12 | * @param extendedExecutor 扩展执行器
13 | * @return 拦截模板实例
14 | */
15 | static Object method(Interceptor interceptor, ExtendedExecutor extendedExecutor) {
16 | return MethodInterceptorFactory.INSTANCE.create(interceptor, extendedExecutor);
17 | }
18 |
19 | /**
20 | * 拦截方法 支持静态和实例方法
21 | *
22 | * @param interceptorClass 拦截器class
23 | * @param extendedExecutor 扩展执行器
24 | * @return 拦截模板实例
25 | */
26 | static Object method(Class interceptorClass, ExtendedExecutor extendedExecutor) {
27 | return MethodInterceptorFactory.INSTANCE.create(interceptorClass, extendedExecutor);
28 | }
29 |
30 | /**
31 | * 拦截构造器
32 | *
33 | * @param interceptor 拦截器
34 | * @param extendedExecutor 扩展执行器
35 | * @return 拦截模板实例
36 | */
37 | static Object constructor(Interceptor interceptor, ExtendedExecutor extendedExecutor) {
38 | return ConstructorInterceptorFactory.INSTANCE.create(interceptor, extendedExecutor);
39 | }
40 |
41 | /**
42 | * 拦截构造器
43 | *
44 | * @param interceptorClass 拦截器class
45 | * @param extendedExecutor 扩展执行器
46 | * @return 拦截模板实例
47 | */
48 | static Object constructor(Class interceptorClass, ExtendedExecutor extendedExecutor) {
49 | return ConstructorInterceptorFactory.INSTANCE.create(interceptorClass, extendedExecutor);
50 | }
51 |
52 | /**
53 | * 增加新方法
54 | *
55 | * @param interceptor 拦截器
56 | * @param extendedExecutor 扩展执行器
57 | * @return 拦截模板实例
58 | */
59 | static Object defineMethod(Interceptor interceptor, ExtendedExecutor extendedExecutor) {
60 | return DefineMethodInterceptorFactory.INSTANCE.create(interceptor, extendedExecutor);
61 | }
62 |
63 | /**
64 | * 增加新方法
65 | *
66 | * @param interceptorClass 拦截器class
67 | * @param extendedExecutor 扩展执行器
68 | * @return 拦截模板实例
69 | */
70 | static Object defineMethod(Class interceptorClass, ExtendedExecutor extendedExecutor) {
71 | return DefineMethodInterceptorFactory.INSTANCE.create(interceptorClass, extendedExecutor);
72 | }
73 |
74 |
75 | Object create(Class interceptorClass, ExtendedExecutor extendedExecutor);
76 |
77 | Object create(Interceptor interceptor, ExtendedExecutor extendedExecutor);
78 | }
79 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/JULLogger.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import java.util.logging.Logger;
4 |
5 | /**
6 | * @author weilong.hu
7 | * @since 2020/12/1 15:57
8 | */
9 | enum JULLogger implements GravityLogger {
10 | /**
11 | * jul logger
12 | */
13 | INSTANCE;
14 |
15 | @Override
16 | public void info(String logName, String msg) {
17 | Logger.getLogger(logName).info(() -> msg);
18 | }
19 |
20 | @Override
21 | public void info(String logName, String format, Object arg) {
22 | Logger.getLogger(logName).info(() -> String.format(format, arg));
23 | }
24 |
25 | @Override
26 | public void info(String logName, String format, Object arg1, Object arg2) {
27 | Logger.getLogger(logName).info(() -> String.format(format, arg1, arg2));
28 | }
29 |
30 | @Override
31 | public void info(String logName, String format, Object... arguments) {
32 | Logger.getLogger(logName).info(() -> String.format(format, arguments));
33 | }
34 |
35 | @Override
36 | public void info(String logName, String msg, Throwable t) {
37 | Logger.getLogger(logName).info(() -> String.format(msg, GravityUtils.getStackTrace(t)));
38 | }
39 |
40 | @Override
41 | public void warn(String logName, String msg) {
42 | Logger.getLogger(logName).warning(() -> msg);
43 | }
44 |
45 | @Override
46 | public void warn(String logName, String format, Object arg) {
47 | Logger.getLogger(logName).warning(() -> String.format(format, arg));
48 | }
49 |
50 | @Override
51 | public void warn(String logName, String format, Object arg1, Object arg2) {
52 | Logger.getLogger(logName).warning(() -> String.format(format, arg1, arg2));
53 | }
54 |
55 | @Override
56 | public void warn(String logName, String format, Object... arguments) {
57 | Logger.getLogger(logName).warning(() -> String.format(format, arguments));
58 | }
59 |
60 | @Override
61 | public void warn(String logName, String msg, Throwable t) {
62 | Logger.getLogger(logName).warning(() -> String.format(msg, GravityUtils.getStackTrace(t)));
63 | }
64 |
65 | @Override
66 | public void error(String logName, String msg) {
67 | Logger.getLogger(logName).warning(() -> msg);
68 | }
69 |
70 | @Override
71 | public void error(String logName, String format, Object arg) {
72 | Logger.getLogger(logName).warning(() -> String.format(format, arg));
73 | }
74 |
75 | @Override
76 | public void error(String logName, String format, Object arg1, Object arg2) {
77 | Logger.getLogger(logName).warning(() -> String.format(format, arg1, arg2));
78 | }
79 |
80 | @Override
81 | public void error(String logName, String format, Object... arguments) {
82 | Logger.getLogger(logName).warning(() -> String.format(format, arguments));
83 | }
84 |
85 | @Override
86 | public void error(String logName, String msg, Throwable t) {
87 | Logger.getLogger(logName).warning(() -> String.format("msg:%s exception:%s", msg, GravityUtils.getStackTrace(t)));
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/JarType.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 | import java.lang.instrument.Instrumentation;
6 | import java.nio.file.Path;
7 | import java.util.Objects;
8 | import java.util.Optional;
9 | import java.util.function.Consumer;
10 | import java.util.jar.JarFile;
11 | import java.util.stream.Stream;
12 |
13 | /**
14 | * Jar包类型，不同类型Jar会被放到不同的目录中
15 | *
16 | * @author duoliang.zhang
17 | * @since 2020/8/12 13:46
18 | */
19 | public enum JarType {
20 | /**
21 | * boot class
22 | */
23 | BOOT {
24 | @Override
25 | public void appendClassPath(Instrumentation instrumentation, Path gravityHome) {
26 | doAppendClassPath(gravityHome.resolve(name().toLowerCase()).toFile(), instrumentation::appendToBootstrapClassLoaderSearch);
27 | }
28 | },
29 | /**
30 | * application class
31 | */
32 | APP {
33 | @Override
34 | public void appendClassPath(Instrumentation instrumentation, Path gravityHome) {
35 | doAppendClassPath(gravityHome.resolve(name().toLowerCase()).toFile(), instrumentation::appendToSystemClassLoaderSearch);
36 | }
37 | },
38 | /**
39 | * agent class
40 | */
41 | AGENT,
42 | /**
43 | * Tomcat WEB-INF/lib
44 | */
45 | TOMCAT;
46 |
47 | private static JarFile newJarFile(File file) {
48 | try {
49 | return new JarFile(file);
50 | } catch (IOException e) {
51 | e.printStackTrace();
52 | return null;
53 | }
54 | }
55 |
56 | private static void doAppendClassPath(File classpath, Consumertrue
46 | */
47 | default boolean ignoreObjectMethod() {
48 | return true;
49 | }
50 |
51 | /**
52 | * 返回当前插件的目击者，用于判断是否支持当前应用的代码增强，默认直接目击
53 | *
54 | * @return 目击者
55 | */
56 | default Witness getWitness() {
57 | return Witness.always();
58 | }
59 |
60 | /**
61 | * 是否双亲委托
62 | */
63 | default boolean isDelegated() {
64 | return false;
65 | }
66 |
67 | /**
68 | * 忽略增强agent classloader下的class
69 | */
70 | default boolean ignoreEnhanceAgentClass() {
71 | return true;
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/PluginJar.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import lombok.Data;
4 |
5 | import java.util.jar.JarFile;
6 |
7 | /**
8 | * 插件Jar包
9 | *
10 | * @author duoliang.zhang
11 | * @since 2020/9/10 16:23
12 | */
13 | @Data
14 | public class PluginJar {
15 | private String name;
16 | private String type;
17 | private String url;
18 | private JarFile file;
19 | }
20 |
--------------------------------------------------------------------------------
/gravity-plugin-api/src/main/java/io/manbang/gravity/plugin/PluginLoader.java:
--------------------------------------------------------------------------------
1 | package io.manbang.gravity.plugin;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * 插件加载器
7 | *
8 | * @author duoliang.zhang
9 | * @since 2020/9/10 16:10
10 | */
11 | public interface PluginLoader extends Ordered, Named {
12 | /**
13 | * 获取一个插件载入器，用来载入插
14 | *
15 | * @return 插件载入器
16 | */
17 | static PluginLoader loader() {
18 | return Services.loadFirst(PluginLoader.class, LocalPluginLoader.INSTANCE);
19 | }
20 |
21 | /**
22 | * 载入插件列表，只是列表清单，没有下载到本地
23 | *
24 | * @param options Agent命令行参数
25 | * @return 插件Jar包列表
26 | */
27 | List