public synchronized void watch() {
    new EventWatchBuilder(watcher)
        .onClass("org.springframework.beans.factory.support.SimpleInstantiationStrategy")
        .onBehavior("instantiate")
        .onWatch(new AdviceAdapterListener(new AdviceListener() {
            @Override
            protected void afterReturning(Advice advice) throws Throwable {
                try {
                    /* (RootBeanDefinition beanDefinition, String beanName...) */
                    String beanName = advice.getParameterArray()[1].toString();
                    Object target = advice.getReturnObj();
                    SpringContextInnerContainer.addBean(beanName, advice.getReturnObj());
                    log.info("Register bean:name={},instance={}", beanName, target);
                } catch (Exception e) {
                    log.error("[Error-2000]-register spring bean occurred error.", e);
                }
            }
        }), Type.BEFORE, Type.RETURN);
}
 

@Override
protected List<EnhanceModel> getEnhanceModels() {
    EnhanceModel em = EnhanceModel.builder()
            .classPattern("com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl")
            .methodPatterns(EnhanceModel.MethodPattern.transform(
                    "queryForObject",
                    "queryForList",
                    "queryWithRowHandler",
                    "queryForPaginatedList",
                    "queryForMap",
                    "insert",
                    "update",
                    "delete")
            )
            .watchTypes(Type.BEFORE, Type.RETURN, Type.THROWS)
            .build();
    return Lists.newArrayList(em);
}
 

@ConstructorProperties({"classPattern", "methodPatterns", "watchTypes", "includeSubClasses"})
EnhanceModel(String classPattern, EnhanceModel.MethodPattern[] methodPatterns, Type[] watchTypes, boolean includeSubClasses) {
    this.classPattern = classPattern;
    this.methodPatterns = methodPatterns;
    this.watchTypes = watchTypes;
    this.includeSubClasses = includeSubClasses;
}
 

/**
 * 行为转换
 *
 * @param behavior 行为模型
 * @return 增强类模型
 */
public static EnhanceModel convert(Behavior behavior) {
    return EnhanceModel.builder()
            .classPattern(behavior.getClassPattern())
            .methodPatterns(MethodPattern.transform(behavior.getMethodPatterns()))
            .includeSubClasses(behavior.isIncludeSubClasses())
            .watchTypes(Type.BEFORE, Type.RETURN, Type.THROWS)
            .build();
}
 

public synchronized void watch(RepeaterConfig config) {
    if (config != null && config.isUseTtl()) {
        new EventWatchBuilder(watcher)
            .onClass("java.util.concurrent.ThreadPoolExecutor").includeBootstrap()
            .onBehavior("execute")
            .onBehavior("submit")
            .onClass("java.util.concurrent.ScheduledThreadPoolExecutor").includeBootstrap()
            .onBehavior("execute")
            .onBehavior("submit")
            .onBehavior("schedule")
            .onBehavior("scheduleAtFixedRate")
            .onBehavior("scheduleWithFixedDelay")
            .onWatch(new AdviceAdapterListener(new AdviceListener() {
                @Override
                protected void before(Advice advice) throws Throwable {
                    // 包装成ttl
                    final Object[] parameterArray = advice.getParameterArray();
                    final Class<?>[] parameterTypeArray = advice.getBehavior().getParameterTypes();
                    if (parameterArray == null || parameterArray.length < 1) {return;}
                    if (parameterArray[0] instanceof com.alibaba.ttl.TtlEnhanced) {return;}
                    Class<?> parameter0Type = parameterTypeArray[0];
                    if (parameter0Type.isAssignableFrom(Runnable.class)) {
                        parameterArray[0] = TtlRunnable.get((Runnable) parameterArray[0]);
                    }
                    if (parameter0Type.isAssignableFrom(Callable.class)) {
                        parameterArray[0] = TtlCallable.get((Callable) parameterArray[0]);
                    }
                }
                // fix issue #41
            }), Type.BEFORE, Type.RETURN, Type.THROWS);
    }
}
 

/**
 * 计算采样率
 *
 * @param event 事件
 * @return 是否采样
 */
protected boolean sample(Event event) {
    if (entrance && event.type == Type.BEFORE) {
        return Tracer.getContext().inTimeSample(invokeType);
    } else {
        final TraceContext context = Tracer.getContext();
        return context != null && context.isSampled();
    }
}
 

@Override
public Object assembleResponse(Event event) {
    if (event.type == Type.RETURN) {
        return ((ReturnEvent) event).object;
    }
    return null;
}
 

@Override
protected List<EnhanceModel> getEnhanceModels() {
    EnhanceModel em = EnhanceModel.builder()
            .classPattern("org.apache.ibatis.binding.MapperMethod")
            .methodPatterns(EnhanceModel.MethodPattern.transform("execute"))
            .watchTypes(Type.BEFORE, Type.RETURN, Type.THROWS)
            .build();
    return Lists.newArrayList(em);
}
 

public Transformer(final Filter filter,
                   final EventListener listener,
                   final Event.Type... eventTypes) {
    this.filter = filter;
    this.listener = listener;
    this.eventTypes = eventTypes;
}
 

public Transformer(final Filter filter,
                   final AdviceListener listener,
                   final Event.Type... eventTypes) {
    this.filter = filter;
    this.listener = new InterruptedAdviceAdapterListener(listener);
    final List<Event.Type> eventTypeList = new ArrayList<Event.Type>();
    CollectionUtils.addAll(eventTypeList, toArray(BEFORE, RETURN, THROWS, IMMEDIATELY_THROWS, IMMEDIATELY_RETURN));
    CollectionUtils.addAll(eventTypeList, eventTypes);
    this.eventTypes = eventTypeList.toArray(new Event.Type[]{});
}
 

public JvmHelper defineClass(final Class<?>[] classes,
                             final Filter filter,
                             final EventListener listener,
                             final Event.Type... eventTypes) throws IllegalAccessException, IOException, InvocationTargetException {
    return defineClass(
            classes,
            new Transformer(filter, listener, eventTypes)
    );
}
 

public Type[] getWatchTypes() {
    return this.watchTypes;
}
 

public JvmHelper defineClass(final Class<?> clazz,
                             final Filter filter,
                             final EventListener listener,
                             final Event.Type... eventType) throws IllegalAccessException, IOException, InvocationTargetException {
    return defineClass(new Class<?>[]{clazz}, filter, listener, eventType);
}
 

/**
 * 是否入口处理开始
 *
 * @param event 事件
 * @return true/false
 */
protected boolean isEntranceBegin(Event event) {
    return event.type == Type.BEFORE;
}
 

/**
 * 是否入口处理完成;非around事件需要重写
 *
 * @param event 事件
 * @return true/false
 */
protected boolean isEntranceFinish(Event event) {
    return event.type != Type.BEFORE
            // 开启trace的类型负责清理
            && Tracer.getContext().getInvokeType() == invokeType;
}