使用Metrics方法级远程监控Java程序(优化)

本文继续上一篇 使用Metrics方法级远程监控Java程序 来讲。在上文中,我们其实只是实现了功能,但是如果做成库,给多个工程使用,那就还差一些。于是我对这个库又做了一些优化。

1 不足点

  1. 写死了切点@RestController,@Controller,和@Service,不灵活。然而我们项目中部分服务还使用了自己自定义的注解,如@XXController和@XXService等(这里就不写具体名字了)。在我们的业务逻辑中同属于Controller层和Service层。如果是之前的编码方式,这些类中的方法就监控不到了。于是我希望监控的切面是可以配置的。
  2. 写死了包名,如果我换一个业务,起不同的包名,就监控不到了。所以我希望包名也是可以配置的。

2 实现可配置的切面

2.1 希望的使用姿势

我希望使用这个库的工程,可以通过以下方式决定自己要监控的类。

import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
// 这是我们自定义的Controller注解
import com.sinafenqi.cashloan.annotations.XXXControler;  

@SpringBootApplication
//通过在Application上加一个注解,配置切点
@MonitorEnable({Controller.class, Service.class, XXXControler.class})  
public class MonitorApplication {

    public static void main(String[] args) {
        SpringApplication.run(MonitorApplication.class, args);
    }

}

我希望可以在Application上使用一个注解(如:MonitorEnable),然后在其中指定切点(甚至自定义的注解)。这样我们便可以任意选择自己想要监控的业务层代码。那么接下来看看如何实现。

2.2 从自定义注解中获取配置的切点

2.2.1 自定义配置使用的注解

首先自定义注解 MonitorEnable ,并定义 value 为Annotation的Class数组。这里我们为了简单,限制一下切点的类型。之后如果需要扩展功能再放开。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MonitorEnable {

    Class<? extends Annotation>[] value();

}

这样其他工程就可以在类上使用这个注解了。接下来我们获取注解中的Value值。

2.2.2 从注解中获取配置的切点

MonitorEnable 作用是提供配置数据的。那么我们想要获取它里面信息的话,需要为 MonitorEnable 加上 @Import 注解,并为其指定一个配置类,这里我们指定 MonitorConfig 为配置类。

更改后的 MonitorEnable 注解文件:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(MonitorConfig.class)
public @interface MonitorEnable {

    Class<? extends Annotation>[] value();

}

要想在 MonitorConfig 配置类中获取 MonitorEnable 中的配置信息,需要实现 ImportAware 接口,这样Spring在加载完 MetaData 的时候会回调 setImportMetadata 方法。我们可以在这里获取注解中的内容。

@Configuration
@Log
public class MonitorConfig implements ImportAware{

    // MonitorProperty类中包装了监控属性。用来存储配置的切点
    public MonitorProperty monitorProperty = new MonitorProperty();  

    // 原来的内容不变,这里省略,详情请参考上一篇文章

    // 这里把MonitorProperty装载到Spring容器。以供其他人使用
    @Bean
    public MonitorProperty monitorProperty() {
        return monitorProperty;
    }

    // 这里获取配置的切点,并设置到monitorProperty中
    @Override
    public void setImportMetadata(AnnotationMetadata annotationMetadata) {
        Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(MonitorEnable.class.getName(), false);
        AnnotationAttributes annotationAttributes = AnnotationAttributes.fromMap(attributes);

        Class<? extends Annotation>[] aopClasses = (Class<? extends Annotation>[]) annotationAttributes.getClassArray("value");
        if (aopClasses == null || aopClasses.length == 0) {
            throw new RuntimeException("monitor cannot get aop annotation classes. nothing to monitor. Please use MonitorEnable annotation on your application.");
        }
        monitorProperty.setAopAnnotationClasses(aopClasses);
    }
}

MonitorProperty类:

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MonitorProperty {

    private Class<? extends Annotation>[] aopAnnotationClasses;

}

这样我们在程序启动中就可以获取 MonitorEnable 使用者配置的值,并且存储在了 MonitorProperty 中。

2.3 根据切点为监控方法准备Timer

现在切点已经是配置进来的了,那么 为监控方法准备Timer 这一步也要做相应更改。这一步比较简单。 MethodMonitorCenter 类增加代码如下,从 MonitorProperty 中获取切点,替换之前写死的逻辑:

@Log
public class MethodMonitorCenter implements ApplicationContextAware {

    // 将MonitorProperty注入进来
    @Autowired
    private MonitorProperty monitorProperty;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> monitorBeans = new HashMap<>();
        // 这里从monitorProperty中获取切点
        Class<? extends Annotation>[] classes = monitorProperty.getAopAnnotationClasses();
        if (classes == null || classes.length == 0) {
            return;
        }
        for (Class<? extends Annotation> aClass : classes) {
            // 这里使用获取的切点获取要监控的类,下面的筛选逻辑与之前相同,省略
            monitorBeans.putAll(applicationContext.getBeansWithAnnotation(aClass));
        }

        // 之后和以前一摸一样,这里省略。
    }

}

2.4 根据切点创建切面

对Spring AOP还不熟悉的读者可以上网上搜索一下。有很多的文章介绍。我就不再赘述了。

我们常见的Spring AOP的使用姿势都是硬编码方式。所谓硬编码的方式就是指,Java注解(我上一篇文章中所使用的方法),和XML配置的方式。现在我们的切点是配置进来的。那么就不能通过硬编码来实现了。然而Java动态代理和AspectJ都需要知道代理目标类。显然也不适合我们这种场景。但是我相信硬编码能够做到的,软编码肯定可以做到,只不过可能会比较麻烦。于是翻了翻Spring源码。找到了方法。本篇文章不想涉及源码和原理,只讲实现。

前提,删除上一篇文章中的 MetricsMonitorAOP 类,因为我们已经不能用硬编码的方式了。

2.4.1 准备创建切面处理类

自定义类 MonitorAdvice 实现 MethodInterceptor 接口,其中的 invoke 方法相当于环绕切面的方法。

@Log
public class MonitorAdvice implements MethodInterceptor {

    MetricRegistry metricRegistry;

    public MonitorAdvice(MetricRegistry metricRegistry) {
        this.metricRegistry = metricRegistry;
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        String methodName = invocation.getMethod().toString();
        log.info("monitor invoke. method: " + methodName);
        boolean contains = metricRegistry.getNames().contains(methodName);
        if (!contains) {
            return invocation.proceed();
        }
        log.info("monitor start method = [" + methodName + "]");
        Timer timer = metricRegistry.timer(methodName);
        Timer.Context context = timer.time();
        try {
            return invocation.proceed();
        } finally {
            context.stop();
        }
    }

}

2.4.2 用软代码根据切点创建切面

MonitorConfig 类中增加代码,讲解请看注释

@Configuration
@Log
// 让MonitorConfig实现BeanFactoryPostProcessor接口,
// 在其postProcessBeanFactory方法中我们可以软代码向Spring装载Bean
public class MonitorConfig implements ImportAware, BeanFactoryPostProcessor {

    // 该类中其他代码保留不变,省略
    // 这里将上面自定义的MonitorAdvice类装载到Spring中
    @Bean
    public MonitorAdvice monitorAdvice(MetricRegistry metricRegistry) {
        return new MonitorAdvice(metricRegistry);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
        MonitorAdvice monitorAdvice = (MonitorAdvice) factory.getBean("monitorAdvice");
        // 获取配置的切点
        Class<? extends Annotation>[] classes = monitorProperty.getAopAnnotationClasses();
        if (classes == null || classes.length == 0) {
            return;
        }
        for (Class<? extends Annotation> aClass : classes) {
            // 软代码根据切点创建Pointcut
            AnnotationMatchingPointcut pointcut = new AnnotationMatchingPointcut(aClass);
            // 软代码创建Advisor(硬编码的方式也是转化成这个东西)
            AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(DefaultPointcutAdvisor.class.getName())
                    .addPropertyValue("pointcut", pointcut)
                    .addPropertyValue("advice", monitorAdvice)
                    .getBeanDefinition();
            // 然后将Advisor装载到Spring
            factory.registerBeanDefinition("monitorAdvisor" + aClass.getName(), beanDefinition);
        }
    }
}

这样,就可以通过软代码的方式实现之前硬编码实现的切面功能。

3 可配置的包名

这个相对于上一个优化简单很多。

3.1 希望的使用姿势

我希望用户可以通过以下两种方式任意一种,达到配置包名的需求

通过 application.properties 文件配置,如,在 application.properties 文件中增加如下代码:

monitor.property.basePackages=com.xxx,com.yyy

或者通过 MonitorEnable 注解进行如下配置:

@MonitorEnable(value = {/*这里是配置的切点们,省略*/}, basePackages = {"com.xxx","com.yyy"})

来实现监控制定的包名。

3.2 实现包名可配置

这里只讲通过 application.properties 文件配置的方式实现方案。通过注解的配置的实现只是获取方式不同,有兴趣的可以直接去看源码。

3.2.1 MonitorProperty增加包名属性

我们可以注意到,3.1中都是可以配置多个包名的,那么在 MonitorProperty 中增加属性 basePackages

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MonitorProperty {

    private Class<? extends Annotation>[] aopAnnotationClasses;

    private String[] basePackages;

}

3.2.2 为MonitorProperty赋值

这一步方法有很多种,我们使用 ConfigurationProperties 注解为其赋值:

@Configuration
@Log
public class MonitorConfig implements ImportAware, BeanFactoryPostProcessor {

    
    @Bean
    // 在装载MonitorProperty的地方加上ConfigurationProperties注解,为其赋值。
    @ConfigurationProperties("monitor.property")
    public MonitorProperty monitorProperty() {
        return monitorProperty;
    }
    
    
}

3.2.3 更改筛选逻辑

已经获取了用户配置的包名,那么我们用用户配置的包名重写原来根据包名筛选的逻辑:

@Log
public class MethodMonitorCenter implements ApplicationContextAware {

    @Autowired
    private MonitorProperty monitorProperty;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> monitorBeans = new HashMap<>();
        
        // 获取要监控的Bean过程省略
        
        monitorBeans.values().stream()
                .map(obj -> obj.getClass().getName())
                .map(this::trimString)
                .map(this::getClass)
                .filter(Objects::nonNull)
                .filter(this::isInPackages) // 这里根据包名过滤
                .forEach(this::getClzMethods);
    }


    private boolean isInPackages(Class<?> clazz) {
        // 根据用户配置的包名过滤想要监控的类
        String[] basePackages = monitorProperty.getBasePackages();
        if (basePackages == null || basePackages.length == 0) {
            return true;
        }
        return Stream.of(basePackages).anyMatch(basePackage -> clazz.getName().startsWith(basePackage));
    }
    
    // 其他代码不变,省略
    
}

这样使用者就可以配置自己的包名了。

4 优化效果

使用者通过在自己的Application类上增加 MonitorEnable 注解,然后可以自定义配置切点:

@MonitorEnable({RestController.class, Controller.class, Service.class, XXControler.class})

然后通过在 application.properties 文件中配置 monitor.property.basePackages 属性,配置自己想监控的包名:

monitor.property.basePackages=com.xxx,com.yyy

然后通过 /monitor/metrics 这个Restful接口获取监控方法的数据。

5 总结

本次优化的两点中,使用软代码方式创建切面是比较困难的,相关的文献比较少。如果有时间,我会单独写一篇文章讲解一下源码和原理。

最后欢迎关注我的个人公众号。提问,唠嗑,都可以。

使用Metrics方法级远程监控Java程序(优化)

本文源码

原文 

https://juejin.im/post/5a4382c46fb9a0450c49b18a

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 使用Metrics方法级远程监控Java程序(优化)

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址