热插拔实现之AOP

---

一、需求背景

最近项目（OSGI框架，目前在做与Spring的兼容）在运行过程中发现日志过大，撑爆硬盘，在随后的分析中，发现是由于之前在项目的接口性能分析中，日志埋点过多，所以在某个业务并发量过大时，出现日志过多，所以考虑是否控制仅在需要进行性能分析时，才进行耗时的打印，而平常正常业务执行时，不记录日志信息。

二、实践代码

本实践主要原理是利用Spring提供的AOP能力，实现所谓热插拔的能力，高手绕行！

1.插件工程

该工程为简单的一个maven工程，由于使用Spring的AOP切面功能，所以需要引入相关的依赖。

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.3</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>
1
2
3
4
5
6
7

功能实现是利用环绕通知:

public class MethodCostAdvise implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        long current = System.currentTimeMillis();
        Object proceed = null;
        try {
            proceed = methodInvocation.proceed();
        } catch (Throwable e) {
            throw e;
        } finally {
            String costString = String.format("[%s] invoke cost:%d ms.", methodInvocation.getMethod().getName(), System.currentTimeMillis() - current);
            System.out.println(costString);
        }
        return proceed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.业务工程

业务工程中，提供了四个接口，分别是：

1. http://localhost:8080/active/plugin/1 激活指定插件
2. http://localhost:8080/deActive/plugin/1 去激活指定插件
3. http://localhost:8080/dog/shut-up 模拟业务接口
4. http://localhost:8080/list/plugin 插件明细查询

该工程是一个简单的SpringBoot的web应用，首先是插件信息加载：

plugins.list[0].id=1 编号
plugins.list[0].cls=com.zte.sdn.plugin.method.MethodCostAdvise 插件类名
plugins.list[0].name=Time Cost by Method 插件名
plugins.list[0].enable=false 插件状态
plugins.list[0].jar=method-time-cost-plugin-1.0.0-SNAPSHOT.jar 插件JAR包

@Data
@Configuration
@ConfigurationProperties(prefix = "plugins")
public class PluginConfig {
    private List<Plugin> list;
}
@Data
@ToString
public class Plugin {
    private int id;
    private String cls;
    private String name;
    private boolean enable;
    private String jar;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

基于AOP进行热插拔进行进行,其前提是Bean是可以插拔的，即是Advise,所以需要定义切面和切入点

@Aspect
@Component
public class DogAspect {
    @Pointcut("execution(public * com.zte.sdn.dog.web.contorl..*.*(..))")
    public void as() {
    }
    @Before("as()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
    }
}
1
2
3
4
5
6
7
8
9
10

Rest实现，具体参考注释

package com.zte.sdn.dog.web.rest;

import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import lombok.extern.slf4j.Slf4j;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.Advised;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.zte.sdn.dog.web.config.Plugin;
import com.zte.sdn.dog.web.config.PluginConfig;
import com.zte.sdn.dog.web.contorl.DogShutUp;

@Slf4j
@RestController
public class PluginControlRest {

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private PluginConfig pluginConfig;

    @Autowired
    private DogShutUp dogShutUp;

    private String pluginDir = "file:E:/00code/";

    private Map<Integer, Advice> adviceMap = new HashMap<>();

    @GetMapping("/list/plugin")
    public String getAllPlugins() {
        return pluginConfig.getList().toString();
    }

    @GetMapping("/active/plugin/{id}")
    public boolean activePlugin(@PathVariable(value = "id") int id) {
        Optional<Plugin> pluginOpt = pluginConfig.getList().stream().filter(p -> p.getId() == id).findFirst();
        if (!pluginOpt.isPresent()) {
            throw new RuntimeException("not find [" + id + "] plugin config");
        }
        Plugin plugin = pluginOpt.get();

        //查询所有Bean实例,并判断是否已被切面过
        for (String bdn : applicationContext.getBeanDefinitionNames()) {
            Object bean = applicationContext.getBean(bdn);
            if (bean == this || !(bean instanceof Advised)) {
                continue;
            }
            //可增强 且未增加过当前指定的advice
            if (!hasAdviced((Advised) bean, plugin.getId())) {
            //借助JAR包装配并构建Advice
                Advice advice = wrapAdviseById(plugin);
                if (advice != null) {
                    ((Advised) bean).addAdvice(advice);
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        return true;

    }

    @GetMapping("/deActive/plugin/{id}")
    public boolean deActivePlugin(@PathVariable(value = "id") int id) {
        for (String bdn : applicationContext.getBeanDefinitionNames()) {
            Object bean = applicationContext.getBean(bdn);
            if (bean == this || !(bean instanceof Advised)) {
                continue;
            }
            if (adviceMap.containsKey(id)) {
                ((Advised) bean).removeAdvice(adviceMap.get(id));
            }
        }
        return true;
    }

    @GetMapping("/dog/shut-up")
    public String dogShutUp() {
        return dogShutUp.shutUp();
    }


    private boolean hasAdviced(Advised bean, int id) {
        Advice advice = adviceMap.get(id);
        if (advice != null) {
            for (Advisor advisor : ((Advised) bean).getAdvisors()) {
                if (advisor.getAdvice() == advice) {
                    return true;
                }
            }
        }
        return false;
    }

	//根据插件信息查找构建advice
    private Advice wrapAdviseById(Plugin plugin) {
        int id = plugin.getId();
        if (adviceMap.containsKey(id)) {
            return adviceMap.get(id);
        }
        try {
            boolean loadJar = false;
            //定位到JAR文件位置
            URL url = new URL(pluginDir + plugin.getJar());
            URLClassLoader loader = (URLClassLoader) getClass().getClassLoader();
            for (URL loaderURL : loader.getURLs()) {
                if (loaderURL.equals(url)) {
                    loadJar = true;
                    break;
                }
            }
            if (!loadJar) {
                Method addURL = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
                addURL.setAccessible(true);
                addURL.invoke(loader, url);
            }
            //加载MethodInterceptor类
            Class<?> aClass = loader.loadClass(plugin.getCls());
            adviceMap.put(id, (Advice) aClass.newInstance());
            return adviceMap.get(id);
        } catch (Exception e) {
            log.error("wrap advise error.", e);
        }
        return null;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

三、演示效果

执行正常调用：

执行加载插件：

再次执行接口调用，控制台会记录并打印接口调用的时间戳

去激活插件后，接口调用耗时打印随即消失

通过上述的思路与实现，可以定义N多个支持热插拔的插件，在运行期启用关闭相关业务功能。