APM系统(Application Performance Management,即应用性能管理),用于对应用系统做实时监控,目的是实现对应用性能管理和故障定位。
APM主要用于对微服务做 “监控及故障发现”,如性能监控,出现故障时发送告警,及辅助排障;更进一步可提前做故障预警。
以电商系统为例,用户的请求链路会经由多个微服务系统后返回:
在线上,当用户的响应时常出现异常时,怎样定位是哪引起的呢?
如果没有tracing系统,研发需要去逐个排查请求链路所经历的每个微服务系统,耗时比较长,且排查定位问题麻烦。
但有了Tracing监控系统,我们可以一眼找到问题。而且,在定位问题后,如果是某个微服务出现了瓶颈,可以根据Tracing的结果查看其请求量增加了多少,从而可精准地判断需要扩容多少机器。
这就是Tracing存在的主要意义。
对微服务的监控,主要包括下面三点:
记录日志,包括正常系统行为,及异常。如把日志存到ES中,再通过Kibana分析。
系统在单位时间内对某一系统指标的度量,如每分钟的请求次数。
如Prometheus和open-falcon都是干这个的,最终展示曲线图给研发人员排障。
Tracing指分布式链路跟踪。在微服务系统中,一个请求会经过多个微服务系统,根据Tracing可在视图上直观看到,请求都经过了哪个微服务,执行时间是多少,从而快速发现是哪个微服务出了问题。
另外,当各个微服务之间的调用依赖关系发生变化,从Tracing的视图中也能够快速的展示出来。
google的经典论文《Dapper, a Large-Scale Distributed Systems Tracing Infrastructure》就是各互联网公司做分布式链路跟踪的理论基础。
Tracing的典型视图是这样子的:
可以看出不同微服务间的调用依赖关系,且可看到每个经过每个微服务的执行时间,从而方便定位性能瓶颈。
成熟的互联网公司,通常都有自己的全方位监控系统,这样可及时发现故障,并为系统优化提供数据支持。
目前流行的APM如下:
美团点评开源,Java语言开发的,但提供了多语言客户端,如Java, C/C++, Node.js, Python, Go等。监控数据全量统计。
CAT需要研发人员手动在代码中添加埋点,是有侵入的。
但Cat Agent也支持探针式无侵入。
目前使用CAT的公司有美团点评、携程、拼多多等。
twitter公司开源,Java语言开发,侵入性比Cat低一些,但需要对web.xml等配置做修改,方便与Spring Cloud集成,也是Spring Cloud推荐的APM系统
韩国开源的APM,基于Java Agent,值需要在启动时添加启动参数,对代码无侵入。支持Java 和 php语言,使用HBase存储数据。但缺点是探针收集数据的粒度非常细,这样性能损耗明显。
Apache顶级项目,支持Java, .Net, Node.js等探针,数据存储支持MySQL, ES等。
Skywalking与Pinpoint相同,采用Java Agent实现,对业务无侵入。但其探针采集粒度较Pinpoint略粗,所以性能更好。
目前,Skywalking社区活跃,中文文档齐全,且支持多种框架,如Dubbo, grpc等。
此外,还有淘宝鹰眼、google dapper等等。
Skywalking是基于OpenTracing规范的、开源的经典的APM系统,专门为微服务架构及云原生而设计的。
Skywalking的核心功能有:
1)服务的指标分析
2)服务的拓扑图分析
3)服务的SLA分析
4)慢查检测
5)告警
Skywalking的特点:
1)多语言探针,如java, .net等
2)为多种开源项目提供插件,如Tomcat, HttpClient, Spring, RabbitMQ, MySQL等各种场景的基础设施与组件提供自动探针
3)微内核 + 插件的架构,存储、集群管理、使用插件可进行自由选择
4)支持告警
5)优秀的可视化效果
Skywalking的架构图:
Skywalking分三个核心部分:
1、Agent:Agent运行在各个服务实例中,负责采集服务实例的Trace, Metrics等数据,然后通过grpc上报给skywalking后端。
2、OAP:Skywalking的后端服务,主要功能有两个:
1)负责接收Agent上报的Trace, Metrics数据,交给Analysis(涉及Skywalking OAP中的多个模块)进行流式分析,并将最终结果写入持久化存储中。Skywalking可支持ES, MySQL等存储。
2)负责响应skywalking UI界面后端发来的查询请求,然后去查持久化数据,组成正确的响应结果返回给UI界面。
3、UI界面:负责将优化的查询请求封装为GraphQL请求提交给OAP后端触发查询操作,并把后端的返回结果在前端展示。
Skywalking监控的目标有三个维度:
1)Service(服务):提供独立功能的模块,单独部署成一个集群对外提供服务
2)ServiceInstance(服务实例):Service集群中的一个节点
3)Endpoint(端点):服务对外暴露的接口,如“/query/userInfo”接口,或RPC接口。
Java agent是独立于主应用程序的代理程序,用来协助检测设置更改替换主应用程序的代码,基于Java Agent可实现虚拟机级别的AOP。
Agent分两种,一种是在主程序之前运行,一种在主程序之后运行。
在JAM启动时,在执行main() 函数前,虚拟机会先找到 -javaagent命令指定的jar包,然后执行 premain-class中的 premain() 方法。所以,premain()函数可以理解为main()函数之前的拦截器。
Java Agent本质上是一个特殊的 jar 包,但它不能单独运行,他必须依附在一个主JVM进程上,所为其“寄生”插件。
Java Agent既然要打成Jar包,首先需要在一个叫做
MANIFEST.MF 文件,通过此文件来指定,其premain-class是哪一个,其需要根据需求定义Can-Redefine-Classes(是否和重新装载)和 Can-Retransform-Classes(是否可传值)。
MANIFEST.MF 文件文件内容如下:
Manifest-Version: 1.0
Premain-Class: com.demo.agent.MyAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
这里注意最后要留一行空行。
import java.lang.instrument.Instrumentation;
import com.alibaba.ttl.threadpool.agent.TtlAgent;
import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;
import net.bytebuddy.utility.JavaModule;
/**
* 我的Java代理
*
*/
public class MyAgent {
/**
* 该方法在main方法之前运行,与main方法运行在同一个JVM中
* 并被同一个System ClassLoader装载
* 被统一的安全策略(security policy)和上下文(context)管理
*
*/
public static void premain(String agentOps, Instrumentation inst) {
System.out.println("this is an perform monitor agent.");
TtlAgent.premain(agentOps, inst);
AgentBuilder.Transformer transformer = new AgentBuilder.Transformer() {
@Override
public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder,
TypeDescription typeDescription,
ClassLoader classLoader) {
return builder
.method(ElementMatchers.<MethodDescription>any()) // 拦截任意方法
// .method(ElementMatchers.nameContains("debug")) // 拦截任意方法
.intercept(MethodDelegation.to(TimeInterceptor.class)); // 委托
}
};
AgentBuilder.Listener listener = new AgentBuilder.Listener() {
@Override
public void onTransformation(TypeDescription typeDescription, ClassLoader classLoader, JavaModule module, DynamicType dynamicType) {}
@Override
public void onIgnored(TypeDescription typeDescription, ClassLoader classLoader, JavaModule module) { }
@Override
public void onError(String typeName, ClassLoader classLoader, JavaModule module, Throwable throwable) {
System.out.println("error typeName:" + typeName + ", exception:" + throwable);
}
@Override
public void onComplete(String typeName, ClassLoader classLoader, JavaModule module) {
// System.out.println("complete typeName:" + typeName);
}
};
new AgentBuilder
.Default()
.type(ElementMatchers.nameStartsWith("com.shanhy.demo.Log")) // 指定需要拦截的类
.transform(transformer)
.with(listener)
.installOn(inst);
System.out.println("=========premain method run 111========");
System.out.println(agentOps);
}
/**
* 如果不存在 premain(String agentOps, Instrumentation inst)
* 则会执行 premain(String agentOps)
*/
public static void premain(String agentOps) {
System.out.println("=========premain method run 2========");
System.out.println(agentOps);
}
}
这里就是MANIFEST.MF中指定的的premain-class叫做MyAgent ,其premain() 函数会在 主应用程序main()函数之前执行,通过他可拦截 主应用程序中的 方法,在被拦截方法前后添加执行指令,设置改写其被拦截方法的执行代码。
premain(String agentOps, Instrumentation inst)函数有两个参数:
1)String agentOps:是 -java agent 命令传进来的参数,如java -cp -javaagent:D:\myagent.jar=abc -jar d:\mydemo.jar中的abc
2)Instrumentation inst:他提供了操作类定义的相关方法
Java Agent工程的pom依赖为:
<dependencies>
<dependency>
<groupId>net.bytebuddygroupId>
<artifactId>byte-buddyartifactId>
<version>1.5.7version>
dependency>
<dependency>
<groupId>net.bytebuddygroupId>
<artifactId>byte-buddy-agentartifactId>
<version>1.5.7version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>transmittable-thread-localartifactId>
<version>2.0.0version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.1.37version>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.pluginsgroupId>
<artifactId>maven-shade-pluginartifactId>
<executions>
<execution>
<phase>packagephase>
<goals>
<goal>shadegoal>
goals>
execution>
executions>
<configuration>
<artifactSet>
<includes>
<include>javassist:javassist:jar:include>
<include>net.bytebuddy:byte-buddy:jar:include>
<include>net.bytebuddy:byte-buddy-agent:jar:include>
<include>com.alibaba:transmittable-thread-local:include>
<include>com.alibaba:fastjson:jar:include>
includes>
artifactSet>
configuration>
plugin>
plugins>
build>
这里重点关注两个依赖:
1)byte-buddy:基于byte-buddy,可更方便拦截 指定类名、方法名,获取方法参数等
2)transmittable-thread-local:可解决对于线程池中的异步线程传递thread local变量值(如traceId)
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.SuperCall;
import com.alibaba.fastjson.JSON;
public class TimeInterceptor {
@RuntimeType
public static Object intercept(@Origin Method method, @SuperCall Callable<?> callable, @AllArguments Object[] args) throws Exception {
long start = System.currentTimeMillis();
try {
// 原有函数执行
System.out.println("premain Object: " + callable);
System.out.println("premain method: " + method);
// System.out.println("premain param list size:" + args.length);
// for (Object obj : args) {
// System.out.println("=========param:" + obj.toString());
// }
if (method.toString().contains("com.shanhy.demo.Log.info")) {
System.out.println(args[0].toString() + ", info, requestId=aaa");
return new String("info");
}
if (method.toString().contains("com.shanhy.demo.Log.debug")) {
System.out.println(args[0].toString() + ", debug, requestId=bbb");
return new String("debug");
}
return callable.call();
// return new String("aaa");
} finally {
// System.out.println(method + " took " + (System.currentTimeMillis() - start) + "ms");
}
}
}
这里注意要选择MANIFEST.MF文件,打包成myagent.jar
随便写个最简单的java 应用程序,并打成可运行的jar包 mydemo.jar
java -cp -javaagent:D:/myagent.jar=traceId123 -jar d:/mydemo.jar
执行结果:
main traceId:null, thread id:1
main traceId2:fa0faca36c414509a1ab99062ee1e9d8, thread id:1
this is log.info, traceId=fa0faca36c414509a1ab99062ee1e9d8, thread id:1
this is log.debug, traceId=fa0faca36c414509a1ab99062ee1e9d8, thread id:1
sub thread run, traceId:fa0faca36c414509a1ab99062ee1e9d8, thread id:12
cleaned traceId:fa0faca36c414509a1ab99062ee1e9d8
get traceId:null
main traceId:null, thread id:1
main traceId2:5db619ae648747f99023e50500f8df9c, thread id:1
this is log.info, traceId=5db619ae648747f99023e50500f8df9c, thread id:1
this is log.debug, traceId=5db619ae648747f99023e50500f8df9c, thread id:1
cleaned traceId:5db619ae648747f99023e50500f8df9c
sub thread run, traceId:5db619ae648747f99023e50500f8df9c, thread id:14
get traceId:null
Thread pool traceId:fa0faca36c414509a1ab99062ee1e9d8, thread id:13
Thread pool traceId:5db619ae648747f99023e50500f8df9c, thread id:15
在 java 5中仅提供了 premain() 方法,他只能在 main() 之前执行;在 java 6 时,提供了agentmain() 方法,可以在man()后执行。
agentmain()方法主要用于 JVM attach工具中,Attach API 是 Java扩展API,可以向目标 JMV “附着” (Attach)一个代理工具程序,这个代理工具程序的入口就是agentmain()。
Java是强类型语言,即在赋值时,一定要明确指定其变量的类型。但这种强类型方式在某些场景下,会带来麻烦:
例如我们对外提供一个通用的jar包,但我们并不知道用户在使用jar时,会传入什么类型的变量或方法,这怎么办呢?虽然Java可通过反射机制,帮我们获取位置类型,及调用其方法,但Java反射的API有两个明显的缺点:
1)早期的JDK版本,反射性能很差
2)反射API会绕过类型安全检查,所以反射API自身并不是类型安全的
为了解决这个问题,“运行时代码生成”在Java应用之后再动态生成一些类定义,这样就可以模拟出,只有动态编程语言才有的特性,同时不会丢失Java强类型检查。
所以,我们借助Byte Buddy这个代码生成库,在运行时生成代码,解决了反射带来的性能问题,同时保留了Java强类型检查。
但这种“运行时代码生成”的方式生成的Java类型,被JVM加载后,一般不会被垃圾回收,因此不应该过度使用此方式。
目前主流的Java代码生成库有:
他是JDK自带的代理工具,允许实现一系列接口的类的代理类,但他要求目标类必须实现接口,这给他带来了限制:例如,在某些场景中,目标类没有实现任何接口且无法修改目标类的代码实现,这时Java Proxy就不行了。
Javassist使用Java源代码字符串和Javassist提供的一些简单API,共同拼凑出用户想要的Java类,Javassist自带一个编译器,拼凑好的Java类在程序运行时会被编译成字节码并加载到JVM中。
javasssit优点是简单易用,且使用Java语法构建类与平时写Java代码类似,但是Javassist编译器在性能上不如Javac编译器,而且在动态组合字符串以实现较复杂的逻辑时容易出错。
Byte Buddy,可通过编写简单的Java代码即可创建自定义的运行时类。且Byte Buddy的定制能力也很好,可应付不同复杂度的需求。
下面是Byte Buddy官方给的数据,显示了代码生产库的性能,单位是纳秒,括号内是标准偏差:
对于代码生成库来说,需要在 “生成快速的代码” 与 “快速生成代码” 之间进行折中。
Byte Buddy折中的考虑是类型动态创建不是程序中的常见步骤,但方法调用等操作很常见,所以,Byte Buddy侧重于生成更快速的代码。
先利用Byte Buddy代码生成库类生成一个类:任何一个由Byte Buddy生成的类都是通过ByteBuddy类的实例来完成的:
DynamicType.Unloaded<?> dynamicType = new ByteBuddy()
.subclass(Object.class) // 生成Object子类
.name("com.demo.Log.info") // 生成类的名称为"com.demo.Log.info"
.make();
包括subclass,Byte Buddy动态增强代码总共有三种方式:
1)subclass:对应ByteBuddy.subclass()方法,就是为目标类(被增强的类)生成一个子类,在子类中插入动态代码。
2)rebasing:对应ByteBuddy.rebasing()方法。当使用rebasing方式增强一个类时,ByteBuddy报错目标类中的所有方法的实现:当Byte Buddy遇到冲突的字段或方法时,会将原理的字段或方法实现,负债到具有兼容签名的重新命名的私有方法中,而不会抛弃这些这段和方法实现,从而达到不丢失的目的。这些重命名的方法可以继续通过重命名后的名称进行调用。
举例说明:
class Foo { // Foo的原始定义
String bar() { return "bar"; }
}
class Foo { //增强后的Foo定义
String bar() {return "foo" + bar$original();}
private String bar$original() {return "bar"}
}
3)redefinition:对应ByteBuddy.redefine()方法。当重新定义一个类时,Byte Buddy可以对一个已有的类添加属性和方法,或者删除已经存在的方法实现。如果使用其他的方法实现替换已经存在的方法实现,则原理存在的方法就会消失。例如,增强Foo类bar()方法使其直接返回“unknown”字符串,增强结果入下:
public Foo { //增强后的Foo定义
String bar() {return "unknow";}
}
通过上述三种方法完成类的增强后,我们得到的是DynamicType.Unloaded对象,表示一个未加载的类型,可以使用ClassLoadingStragegy加载此类型。
Byte Buddy提供了几种类加载策略,这些策略定义在ClassLoadingStrategy.Default中:
1)WRAPPER策略:创建一个新的ClassLoader来加载动态生成的类型
2)CHILD_FIRST:创建一个子类优先加载的ClassLoader,即打破了双亲委派模型。
3)INJECTION策略:使用反射将动态生成的类型直接注入到当前的ClassLoader中。
具体使用方式如下:
Class<?> loaded = new ByteBuddy()
.subclass(Object.class) // 生成Object子类
.name("com.demo.Log.Info") // 生成类的名称为"com.demo.Log.info"
.make()
.load(Info.class.getClassLoader(),ClassLoadingStrategy.Default.WRAPPER)
.getLoaded();
这里动态生成的com.demo.Log.Info类只是简单继承了Object类,在实际应用中动态生成新类型的目的一般就是为了增强原始的方法。
下面的例子是Byte Buddy如何增强toString()方法:
String str = new ByteBuddy()
.subclass(Object.class)
.name("com.demo.Log.Info")
.method(ElementMatchers.named("toString"))
.intercept(FixedValue.value("Hello World"))
.make()
.load(ByteBuddy.class.getClassLoader())
.getLoaded()
.newInstance()
.toString();
System.out.pritnln(str);
这里,首先关注method()方法,method() 方法可以通过传入的ElementMathers参数匹配多个需要修改的方法,这里的ElementMatchers.named(“toString”) 即为按照方法名匹配的toString()方法,如果存在多个重载方法,则可以通过使用ElementMathcers其他API描述的方法签名,如:
ElementMatchers.named("toString") // 指定方法名称
.and(ElementMatchers.returns(String.class)) //指定方法的返回值
.and(ElementMatchers.takesArguments(0)) // 指定方法参数
接下来关注intercept()方法,通过method()方法拦截到的所有方法都会由intercept()方法指定的Implementation对象决定如何增强。这里的FixValue.value()会将方法的实现修改为固定值,上例中就是返回“Hello world”字符串。
Byte Buddy可以设置多个method()和intercept()方法进行拦截和修改,Byte Buddy会按照栈的顺序来进行拦截。下面例子会进行说明:
一个Info类有三个方法:
class Foo{
public String bar() {return null;}
public String foo() {return null;}
public String foo(Object o) {return null;}
}
接下来,用Byte Buddy动态生成一个Foo的子类,并修改其中的方法:
Foo dynamiceFoo = new ByteBuddy().subclass(Foo.class)
.method(ElementMatchers.isDeclaredBy(Foo.class)).intercept(FixedValue.value("One!"))
.method(ElementMatchers.named("foo")).intercept(FixedValue.value("Two!"))
.method(ElementMatchers.named("foo").and(ElementMatchers.takesArguments(1))) // 匹配名为foo且只有一个参数的方法
.intercept(FixedValue.value("Three!"))
.make()
.load(getClass().getClassLoader(), ClassLoadingStrategy.Default.INJECTION).getLoaded().newInstance();
System.out.println(dynamiceFoo.bar());
System.out.println(dynamiceFoo.foo());
System.out.println(dynamiceFoo.foo(0));
这里的输出结果是
One!
Tow!
Three!
这里,需要在Java Agent中就知道要拦截的类,要可以import进来才行。而要拦截的类,应该跟Java Agent不从属于同一个工程,且这里采用反射机制,性能不够好。
上面的例子中,是修改指定方法的入参,是实际应用中,更多的场景是将拦截的方法交给代理类去处理。下面的例子是对MethodDelegation的使用:
首先创建一个DB的目标类:
class DB {
public String hello(String name) {
System.out.println("DB:" + name);
return null;
}
}
再使用Byte Buddy对其进行增强:
String helloworld = new ByteBuddy().subclass(DB.class)
.method(ElementMatchers.named("hello")) // 拦截DB.hello()方法,并委托给Interceptor中的静态方法处理
.intercept(MethodDelegation.to(MyInterceptor.class))
.make()
.load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.INJECTION)
.getLoaded()
.newInstance()
.hello("world");
System.out.println(helloworld);
下面看MyInterceptor类的定义:
class MyInterceptor {
public static String intercept(String name) {return "String";}
public static String intercept (int i) {return "int";}
public static String intercept (Object o) {return "Object";}
}
但是MyInterceptor类有三个方法,会匹配到哪个呢?答:intercept(String name),因为匹配是回根据重载时参数来选择的,如果没有intercept(String name),则会匹配到intercept(Object o)。
对于MethodDelegation,除了上述通过API拦截方法,并将方法委托给Interceptor增强外,Byte Buddy还提供了一系列预定义的注解,通过这些注解,我们可以告知Byte Buddy将哪些需要的数据注入到Interceptor中。
下面介绍Byte Buddy中常用的注解:
class MyInterceptor {
@RuntimeType
public Object intercept (
@This Object obj, // 目标对象
@AllArguments Object[] allArguments, // 注入目标方法的全部参数
@SuperCall Callable<?> callable, // 调用目标方法,必不可少
@Origin Method method, // 目标方法
@Super DB db // 目标对象
) throws Exception {
System.out.println(obj);
System.out.println(db);
try {
return callable.call();
} finally {
}
}
}
这里对注解做详细说明:
1)@RuntimeType注解:告诉Byte Buddy不要进行严格的参数类型检测,在参数匹配失败时,尝试使用类型转换(runtime type casting)匹配相应的方法。
2)@AllArguments注解:注入目标方法的全部参数,长得跟Java反射的API有些类似了
3)@Origin注解:注入目标方法对应的Method对象,如果拦截的是字段的话,该注解应该标注到Field类型参数。
4)@Super注解:注入目标对象。通过该对象可以调用目标对象的所有方法
5)@SuperCall注解:这个注解用于在intercept()方法中调用目标方法,但在这里不能修改调用参数。
关于MethodDelegation.to委托的方式:
MethodDelegation.to(MyInterceptor.class) //委托到MyInterceptor的静态方法
MythodDelegation.to(new MyInterceptor())// 委托到Interceptor的实例方法
前面说过,使用@SuperCall注解注入的Callable来调用目标方法时,是无法动态修改参数的,如果想要动态修改参数,则需要用到 @Morph 注解及一些绑定动作。示例如下:
package com.shp.demo;
import com.shp.agent.Hello3Interceptor;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.implementation.bind.annotation.Morph;
import net.bytebuddy.matcher.ElementMatchers;
public class DB {
DB dynamic = null;
public String hello(String name) {
System.out.println("DB:" + name);
return null;
}
public String hello(int name) {
System.out.println("DB:" + name);
return null;
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
// DB dynamic = new ByteBuddy().subclass(DB.class)
// .method(ElementMatchers.named("hello")).intercept(MethodDelegation.to(new Hello2Interceptor())).make()
// .load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.INJECTION)
// .getLoaded().newInstance();
DB dynamic = new ByteBuddy().subclass(DB.class)
.method(ElementMatchers.named("hello")).intercept(MethodDelegation.withDefaultConfiguration().withBinders(
Morph.Binder.install(OverrideCallable.class)).to(new Hello3Interceptor())).make()
.load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.INJECTION).getLoaded().newInstance();
dynamic.hello("world");
}
}
package com.shp.demo;
public interface OverrideCallable {
Object call(Object[] args);
}
package com.shp.agent;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import com.shp.demo.DB;
import com.shp.demo.OverrideCallable;
import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.Morph;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.Super;
import net.bytebuddy.implementation.bind.annotation.SuperCall;
import net.bytebuddy.implementation.bind.annotation.This;
public class Hello3Interceptor {
@RuntimeType
public Object intercept(@This Object obj, // 目标对象
@AllArguments Object[] allArguments, // 注入目标方法的全部参数
@Origin Method method, // 目标方法
@Super DB db, // 目标对象
@Morph OverrideCallable callable
// @SuperCall Callable callable
) throws Throwable {
System.out.println("=========method:" + method.getName());
System.out.println("==========class:" + db.getClass().getName());
System.out.println("============param:" + allArguments[0]);
try {
System.out.println("before:" + allArguments[0]);
allArguments[0] = allArguments[0] + "abc";
Object result = callable.call(allArguments);
// System.out.println("after");
return result;
} catch (Throwable t) {
throw t;
} finally {
System.out.println("finally");
}
}
}