Agent源码解析

public static void premain(String agentArgs, Instrumentation instrumentation) throws PluginException {
  ... ...
}

//先声明一个资源加载器resolver，在resolver中的getResources()会查找skywalking-plugin.def文件中定义的类
PluginResourcesResolver resolver = new PluginResourcesResolver();
List<URL> resources = resolver.getResources();

//循环load skywalking-plugin.def ,并且解析该文件
for (URL pluginUrl : resources) {
    try {
        PluginCfg.INSTANCE.load(pluginUrl.openStream());
    } catch (Throwable t) {
        LOGGER.error(t, "plugin file [{}] init failure.", pluginUrl);
    }
}

//加载skywalking-plugin.def的类，保存到list中
List<PluginDefine> pluginClassList = PluginCfg.INSTANCE.getPluginClassList();

List<AbstractClassEnhancePluginDefine> plugins = new ArrayList<AbstractClassEnhancePluginDefine>();

//通过反射创建这些类的实例
for (PluginDefine pluginDefine : pluginClassList) {
    try {
        LOGGER.debug("loading plugin class {}.", pluginDefine.getDefineClass());
        AbstractClassEnhancePluginDefine plugin = (AbstractClassEnhancePluginDefine) Class.forName(pluginDefine.getDefineClass(), true, AgentClassLoader
            .getDefault()).newInstance();
        plugins.add(plugin);
    } catch (Throwable t) {
        LOGGER.error(t, "load plugin [{}] failure.", pluginDefine.getDefineClass());
    }
}

//最后返回plugins
return plugins;

//定义了集合
//pluginFinder将插件分类保存在两个集合中，分别是：按名字分类和按其他辅助信息分类
private final Map<String, LinkedList<AbstractClassEnhancePluginDefine>> nameMatchDefine = new HashMap<String, LinkedList<AbstractClassEnhancePluginDefine>>();
private final List<AbstractClassEnhancePluginDefine> signatureMatchDefine = new ArrayList<AbstractClassEnhancePluginDefine>();
private final List<AbstractClassEnhancePluginDefine> bootstrapClassMatchDefine = new ArrayList<AbstractClassEnhancePluginDefine>();

//构造方法
public PluginFinder(List<AbstractClassEnhancePluginDefine> plugins) {
    for (AbstractClassEnhancePluginDefine plugin : plugins) {
        //抽象方法enhanceClass方法定义在插件的抽象基类AbstractClassEnhancePluginDefine中，每一个插件必须去实现这个类中的方法
        //故enhanceClass是每个插件都会自己去实现的方法，指定需要增强的类
        ClassMatch match = plugin.enhanceClass();

        if (match == null) {
            continue;
        }

        if (match instanceof NameMatch) {
            NameMatch nameMatch = (NameMatch) match;
            LinkedList<AbstractClassEnhancePluginDefine> pluginDefines = nameMatchDefine.get(nameMatch.getClassName());
            if (pluginDefines == null) {
                pluginDefines = new LinkedList<AbstractClassEnhancePluginDefine>();
                nameMatchDefine.put(nameMatch.getClassName(), pluginDefines);
            }
            pluginDefines.add(plugin);
        } else {
            signatureMatchDefine.add(plugin);
        }

        if (plugin.isBootstrapInstrumentation()) {
            bootstrapClassMatchDefine.add(plugin);
        }
    }
}

//typeDescription是bytebuddy的内置接口，是对类的完整描述，包含了类的全类名
//传入typeDescription，返回可以运用于typeDescription的类的插件
public List<AbstractClassEnhancePluginDefine> find(TypeDescription typeDescription) {
    List<AbstractClassEnhancePluginDefine> matchedPlugins = new LinkedList<AbstractClassEnhancePluginDefine>();
    String typeName = typeDescription.getTypeName();
    //根据名字信息匹配查找
    if (nameMatchDefine.containsKey(typeName)) {
        matchedPlugins.addAll(nameMatchDefine.get(typeName));
    }
    //通过除了名字之外的辅助信息，在signatureMatchDefine集合中查找
    for (AbstractClassEnhancePluginDefine pluginDefine : signatureMatchDefine) {
        IndirectMatch match = (IndirectMatch) pluginDefine.enhanceClass();
        if (match.isMatch(typeDescription)) {
            matchedPlugins.add(pluginDefine);
        }
    }

    return matchedPlugins;
}

public ElementMatcher<? super TypeDescription> buildMatch() {
    //设置匹配的规则，名字是否相同，通过名字直接匹配
    ElementMatcher.Junction judge = new AbstractJunction<NamedElement>() {
        @Override
        public boolean matches(NamedElement target) {
            return nameMatchDefine.containsKey(target.getActualName());
        }
    };
    //接口不增强，排除掉
    judge = judge.and(not(isInterface()));
    //如果无法确定类的全限定名，则通过注解、回调信息等辅助方法间接匹配
    for (AbstractClassEnhancePluginDefine define : signatureMatchDefine) {
        ClassMatch match = define.enhanceClass();
        if (match instanceof IndirectMatch) {
            judge = judge.or(((IndirectMatch) match).buildJunction());
        }
    }
    return new ProtectiveShieldMatcher(judge);
}

public List<AbstractClassEnhancePluginDefine> getBootstrapClassMatchDefine() {
    return bootstrapClassMatchDefine;
}

//间接继承了基类
public class WrapperInstrumentation extends ClassStaticMethodsEnhancePluginDefine {
    @Override
    public StaticMethodsInterceptPoint[] getStaticMethodsInterceptPoints() {
        return new StaticMethodsInterceptPoint[] {
            new StaticMethodsInterceptPoint() {
                @Override
                public ElementMatcher<MethodDescription> getMethodsMatcher() {
                    return named("makeWrapper");
                }

                @Override
                public String getMethodsInterceptor() {
                    return "org.apache.skywalking.apm.plugin.dubbo.patch.MakeWrapperInterceptor";
                }

                @Override
                public boolean isOverrideArgs() {
                    return false;
                }
            }
        };
    }

    //重写了基类的enhanceClass()方法，指定了需要增强的类
    @Override
    protected ClassMatch enhanceClass() {
        return byName("com.alibaba.dubbo.common.bytecode.Wrapper");
    }
}

agentBuilder.type(pluginFinder.buildMatch())
            .transform(new Transformer(pluginFinder))
            .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
            .with(new Listener())
            .installOn(instrumentation);

private static class Transformer implements AgentBuilder.Transformer {
    private PluginFinder pluginFinder;

    Transformer(PluginFinder pluginFinder) {
        this.pluginFinder = pluginFinder;
    }

    @Override
    public DynamicType.Builder<?> transform(final DynamicType.Builder<?> builder,
                                            final TypeDescription typeDescription,
                                            final ClassLoader classLoader,
                                            final JavaModule module) {
        //typeDescription是bytebuddy的内置接口，是对类的完整描述，包含了类的全类名
        //这里返回的是所有可以运用于typeDescription的类的插件【一个类可能有多个插件，见def文件】
        List<AbstractClassEnhancePluginDefine> pluginDefines = pluginFinder.find(typeDescription);
        if (pluginDefines.size() > 0) {
            DynamicType.Builder<?> newBuilder = builder;
            EnhanceContext context = new EnhanceContext();
            for (AbstractClassEnhancePluginDefine define : pluginDefines) {
                DynamicType.Builder<?> possibleNewBuilder = define.define(
                        typeDescription, newBuilder, classLoader, context);
                if (possibleNewBuilder != null) {
                    newBuilder = possibleNewBuilder;
                }
            }
            if (context.isEnhanced()) {
                LOGGER.debug("Finish the prepare stage for {}.", typeDescription.getName());
            }

            return newBuilder;
        }

        LOGGER.debug("Matched class {}, but ignore by finding mechanism.", typeDescription.getTypeName());
        return builder;
    }
}

//BootService中声明的生命周期方法，agent-core内核会在适当的时机调用不同的生命周期方法
public interface BootService {
    void prepare() throws Throwable;

    void boot() throws Throwable;

    void onComplete() throws Throwable;

    void shutdown() throws Throwable;
}

try {
    ServiceManager.INSTANCE.boot();
} catch (Exception e) {
    LOGGER.error(e, "Apm agent boot failure.");
}

public void boot() {
    bootedServices = loadAllServices();

    prepare();
    startup();
    onComplete();
}

Runtime.getRuntime()
                .addShutdownHook(new Thread(ServiceManager.INSTANCE::shutdown, "apm service shutdown thread"));