一种基于Spring Boot实现的支持热插拔的插件化方案_springboot 插件化 classloader

背景

在Spring Boot开发的过程中，可能会遇到一些场景：1）希望在已有的系统添加一块临时代码，用于某项市场验证等。在市场验证结束后又能够将这块临时代码从项目中彻底清除；2）一部分附属于主系统的外围功能，需要独立的开发和维护。此时需要用到插件化的技术来实现。本文将介绍一种在Spring Boot之上实现支持热插拔的插件化方案。

主要思路

通过自定义ClassLoader来加载插件包内的类。并将定义在插件中的Bean注册到Ioc容器中。在此过程中需要打破Java类加载机制本身的双亲委派机制。

双亲委派机制

1. 当调用一个ClassLoader的loadClass方法时，它先不调用自身的类加载方法，而是将类加载的过程委派给自己的双亲类加载器（调用双亲类加载器的loadClass方法）。
2. 当双亲类加载器加载成功时，直接返回加载成功的类
3. 当双亲类加载器加载失败时，再调用自身的findClass方法。

打破双亲委派机制

1. 在插件化的过程中，在调用ClassLoader的loadClass方法时，需要先判断该类是否属于插件中的类。判断的一个类是否属于插件中的类的方法有很多。比如当一个类的包名匹配**.plugins.{{pluginName}}.{{className}}。就认为这个类来自名称为{{pluginName}}的插件。
2. 若该类不属于插件中定义的类，则调用系统原来的ClassLoader加载该类，继续按双亲委派机制执行。
3. 若该类属于插件类，则先根据{{pluginName}}找到相应的插件类加载器，然后调用插件类加载器的loadClass方法。

自定义支持插件的类加载器

HotSwapPluginClassLoader类的loadClass方法会根据加载的类是否属于插件类，以及类对应的插件名来选择合适的插件类加载器，并通过插件类加载器来加载插件类，通过自身的双亲类来加载非插件类。

/** imports **/
public class HotSwapPluginClassLoader extends ClassLoader implements SmartClassLoader {
	
	private Map<String, PluginDefinition> pluginDefinitionMap = new ConcurrentHashMap();

	public static final HotSwapPluginClassLoader INSTANCE = new HotSwapClassLoader();

	@Override
	protected Class<?> loadClass(String name, boolean resolve) throw ClassNotFoundException {
		synchronized(this.getClassLoadingLock(name)) {
			Class<?> c = null;
			/**获取插件名，若插件名为null表示该类不是插件中定义的类**/
			String pluginName = this.getPluginName(name);
			/**不是插件中的类，按双亲委派机制执行**/
			if(pluginName == null) {
				try {
					c = this.getParent().loadClass(name);
				} catch (ClassNotFoundException e) {
				}
			} else {
				PluginDefinition pluginDefinition = this.pluginDefinitionMap.get(pluginName);
				if(pluginDefinition != null) {
					try {
						c = pluginDefinition.getPluginClassLoader().loadClass(name, false);
					} catch(ClassNotFoundException e) {
					}
				}
			}
			if(c == null) {
				throw new ClassNotFoundException(name);
			}
			return c;
		}
	}

	/**注册插件**/
	public ClassLoader register(String pluginName, File jarFile) {
		pluginName = Objects.requireNonNull(pluginName);
		jarFile = Objects.requireNonNull(jarFile);
		try {
			URL url = jarFile.toURI().toURL();
			ClassLoader pluginClassLoader = new PluginClassLoader(new URL[]{url}, this);
			this.pluginDefinitionMap.put(pluginName, new PluginDefinition(pluginName, pluginClassLoader));
			return pluginClassLoader;
		} catch(MalformatedURLException e) {
			throw new RuntimeException(e);
		}
	}
	
	/**注销插件**/
	public void unregister(String pluginName) {
		pluginName = Objects.requireNonNull(pluginName);
		PluginClassLoader pluginClassLoader = this.pluginDefinitionMap.get(pluginName).getPluginClassLoader();
		try {
		pluginClassLoader.close();
		} catch(IOException e) {
			e.pringStackTrace();
		}
		this.pluginDefinitionMap.remove(pluginName);
	}
	
	/**根据类名获取插件名，不是插件中定义的类时返回null**/
	public String getPluginName(String className) {
		/**忽略**/
	}

	@Override
	public boolean isClassReloadable(Class<?> aClass) {
		/**插件中的定义的类允许重新加载**/
		return this.getPluginName(aClass.getName) != null;
	}
	
	public static class PluginClassLoader extends URLClassLoader implements SmartClassLoader {
		
		private final HotSwapPluginClassLoader parent;

		protected PluginClassLoader(URL[] urls, HotSwapPluginClassLoader parent) {
			super(urls, parent);
			this.parent = parent;
		}
		
		@Override 
		public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
			Class<?> c = null;
			if(this.parent.getPluginName(name) != null) { /**插件类，自己处理**/
				c = this.findLoadedClass(name);
				if(c == null) {
					try {
						c = this.findClass(name);
					} catch(ClassNotFoundException e) {
					}
				}
			} else { /**非插件类，委托双亲处理**/
				c = this.parent.loadClass(name);
			}
			if(c != null) {
				if(resolve) resolveClass(c);
				return c;
			}
			throw new ClassNotFoundException(name);
		}
		
		@Override
		public boolean isClassReloadable(Class<?> aClass) {
			return true;
		}
	}

	
}
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

插件服务

有了插件类加载器HotSwapPluginClassLoader后，就可以调用该类的register方法来注册插件的jar文件，并加载插件中的类了。但是还需要一个服务来将插件的装载、卸载等过程转换为一般的api操作。
先定义插件信息Holder类，来保存插件中的Bean信息

public class PluginHolder {
	private String pluginName;
	
	/**api请求信息**/
	private Set<RequestMappingInfo> requestMappingInfoSet = new HashSet();

	/**插件中的bean定义信息**/
	private Set<BeanDefinitionWrap> beanDefinitionWrapSet = new HashSet();

	/** getters and setters **/
}
1
2
3
4
5
6
7
8
9
10
11

装载插件loadPlugin和卸载插件unloadPlugin

@Service
public class PluginService {

/**忽略**/

private ConcurrentHashMap<String, PluginHolder> pluginHolderMap = new ConcurrentHashMap();

/**装载插件**/
public synchronized void loadPlugin(String pluginName, File jarFile) {
	HotSwapPluginClassLoader classLoader = HotSwapPluginClassLoader.INSTANCE;
	DefaultListableBeanFactory registry = (DefaultListableBeanFactory) this.applicationContext.getAutowiredCapableBeanFactory();
	
	PluginHolder holder = this.pluginHolderMap.get(pluginName);
	if(holder != null) {
		this.unloadPlugin(holder.getPluginName());
	}
	holder = new PluginHolder();
	holder.setPluginName(pluginName);
	this.pluginHolderMap.put(pluginName, holder);
	
	ClassLoader pluginClassLoader = classLoader.register(pluginName, jarFile);
	/**设置动态代理的ClassLoader**/
	this.setProxyClassLoader(registry, pluginClassLoader);

	try {
		/**获取插件中的Bean定义，并注册Bean**/
		Set<BeanDefinitionWrap> beanDefinitionWraps = this.doGetBeanDefinitions(pluginClassLoader);
		for(BeanDefinitionWrap wrap : beanDefinitionWraps) {
			try {
				if(registry.containsSingleton(wrap.getBeanName())) {
					registry.destroySingleton(wrap.getBeanName());
				}
			} catch(Exception e) {
			}
		
			try{
				if(registry.containsBeanDefinition(wrap.getBeanName())) {
					register.removeBeanDefinition(wrap.getBeanName());
				}
			} catch(Exception e) {
			}
		
			registry.registerBeanDefinition(wrap.getBeanName(), wrap.getDefinition());
			holder.getBeanDefinitionWrapSet().add(wrap);
		}
	
		/**注册插件中定义的Controller**/
		for(BeanDefinitionWrap wrap : beanDefinitionWraps) {
			Set<RequestMappingInfo> requestMappingInfoSet = this.doRegisterRequestController(wrap.getBeanName(), wrap.getBeanType());
			holder.getRequestMappingInfoSet().addAll(requestMappingInfoSet);
		}
	} catch(Exception e) {
		this.doReleasePluginHolder(holder);
	} finally {
		/**还原动态代理的ClassLoader**/
		this.setProxyClassLoader(registry, classLoader);
	}
	
}

/**卸载插件**/
public void unloadPlugin(pluginName) {
	PluginHolder holder = this.pluginHolderMap.get(pluginName);
	HotSwapPluginClassLoader classLoader = HotSwapPluginClassLoader.INSTANCE;
	if(holder != null) {
		/**释放插件**/
		this.doReleasePluginHolder(holder);
		/**注销插件的类加载器**/
		classLoader.unregister(pluginName);
	}
}

/**设置动态代理的ClassLoader，对于通过CGLib实现的动态代理类，加载过程中不是使用当前线程的ClassLoader，而是使用AbstractAutoProxyCreator中的proxyClassLoader。因此，需要手动修改AbstractAutoProxyCreator中的proxyClassLoader属性。**/
private void setProxyClassLoader(DefaultListableBeanFactory registry, ClassLoader classLoader) {
	/**AbstractAutoProxyCreator类是BeanPostProcessor接口的实现，通过遍历BeaenPostProcessor列表获取到它的实例**/
	List<BeanPostProcessor> postProcessors = registry.getBeanPostProcessors();
	for(BeanPostProcessor postProcessor : postProcessors) {
		if(postProcessor instanceof AbstractAutoProxyCreator) {
			((AbstractAutoProxyCreator) postProcessor).setProxyClassLoader(classLoader);
		}
	}
}

/**获取插件中的Bean定义**/
private Set<BeanDefinitionWrap> doGetBeanDefinitions(ClassLoader pluginClassLoader) {
	/**Bean的候选集合**/
	Set<BeanDefinitionWrap> candidates = new HashSet();
	
	ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(pluginClassLoader);
	Resource[] resources = resourcePatternResolver.getResources("classpath*:**/plugins/**/*.**");
	AnnotationBeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
	DefaultListableBeanFactory register = (DefaultListableBeanFactory) this.applicationContext.getAutowireCapableBeanFactory();
	
	MetadataReaderFactory metadata = new SimpleMetadataReaderFactory();
	for(Resource resource : resources) {
		try {
			MetadataReader metadataReader = metadata.getMetadataReader(resource);
			String className = metadataReader.getClassMetadata().getClassName();
			Class beanClass = pluginClassLoader.loadClass(className);
			AnnotatedGenericBeanDefinition abd = new PluginClassBeanDefinition(beanClass);
			
			BeanDefinitionWrap wrap = new BeanDefinitionWrap(abd);
			wrap.setBeanType(beanClass);
			candicates.add(wrap);
		} catch(Throwable e) {
			e.printStackTrace();
		}
	}
	
	/**筛选出bean**/
	Set<BeanDefinitionWrap> result = new HashSet();
	for(BeanDefinitionWrap wrap : candicates) {
		Class<?> aClass = wrap.getBeanType();
		Controller controller = aClass.getAnnotation(Controller.class);
		RestController restController = aClass.getAnnotation(RestController.class);
		Service service = aClass.getAnnotation(Service.class);
		Component component = aClass.getAnnotation(Component.class);
		wrap.setController(controller != null || restController != null);
		wrap.setService(service != null);
		wrap.setComponent(component != null);
	
		if(wrap.isComponent() || wrap.isController() || wrap.isService()) {
			wrap.setBeanName(beanNameGenerator.generateBeanName(wrap.getDefinition(), register));
			result.add(wrap);
		}
	}
	return result;
}

private void doReleasePluginHolder(PluginHolder holder) {
	/**注销插件中定义的Api请求**/
	for(RequestMappingInfo requestMappingInfo : holder.getRequestMappingInfoSet()) {
		try {
			this.doUnregisterRequestMappingInfo(requestMappingInfo);
		} catch(Exception e) {
		}
	}
	/**注销插件中定义的Bean**/
	DefaultListableBeanFactory registry = (DefaultListableBeanFactory) this.applicationContext.getAutowiredBeanFactory();
	for(BeanDefinitionWrap wrap : holder.getBeanDefinitionWrapSet()) {
		try {
			registry.removeBeanDefinition(beanDefinitionWrap.getBeanName());
		} catch(Exception e) {
		}
	}
}



/**Bean定义修饰，包含附加信息**/
private static class BeanDefinitionWrap {
	
	/**Bean定义**/
	BeanDefinition definition;
	
	/**被@Controller注解**/
	private boolean isController;

	/**被@Service注解**/
	private boolean isService;
	
	/**被@Component注解**/
	private boolean isComponent;

	private String beanName;
	
	private Class<?> beanType;

	public BeanDefinitionWrap(BeanDefinition definition) {
		this.definition = definition;
	}

	/** getters and setters**/
	
}

/**忽略**/
}
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

注册和注销插件中定义的Api

@Service
public class PluginService {
/**忽略**/

/**注册插件中定义的api**/
private Set<RequestMappingInfo> doRegisterRequestController(String beanName, Class controllerClzz) {
	Object proxy = this.applicationContext.getBean(beanName);
	
	RequestMappingHandlerMapping requestMappingHandlerMapping = this.applicationContext.getBean(RequestMappingHandlerMapping.class);
	
	/**通过反射的方式调用getMappingForMethod方法**/
	Method getMappingForMethod = ReflectionUtils.findMethod(RequestMappingHandlerMapping.class, "getMappingForMethod", Method.class, Class.class);
	getMappingForMethod.setAccessible(true);
	
	Set<RequestMappingInfo> requestMappingInfoSet = new HashSet();
	try {
		Method[] methodArr = controllerClzz.getMethods();
		for(Method method : methodArr) {
			RequestMappingInfo mappingInfo = (RequestMappingInfo) getMappingForMethod.invoke(requestMappingHandlerMapping, method, controllerClzz);
			if(mappingInfo != null) {
				requestMappingHandlerMapping.registerMapping(mappingInfo, proxy, method);
				requestMappingInfoSet.add(mappingInfo);
			}
		}
	} catch(Exception e) {
		e.pringStackTrace();
	}
	return requestMappingInfoSet;
}

/**注销插件中定义的api**/
private void doUnregisterRequestMappingInfo(RequestMappingInfo requestMappingInfo) {
	RequestMappingHandlerMapping requestMappingHandlerMapping = this.applicationContext.getBean(RequestMappingHandlerMapping.class);

        requestMappingHandlerMapping.unregisterMapping(requestMappingInfo);
}


/**忽略**/
}
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

综述

本文所阐述的支持热替换的插件化方案，主要思路是通过自定义类加载器来加载插件中的类，并从中筛选出有Bean定义的类，并将Bean定义注册到系统Ioc容器中。若Bean中存在@Controller注解的类，还需要对该类中的api映射方法做进一步处理。

该方案能够实现基础的热插拔插件功能，但是仍然不够全面。例如：

• 只能识别@Controller、@Service、@Component定义的Bean，对于Spring中继承自@Component注解的Bean以及通过@Bean注解定义的Bean并未处理。
• 当系统加载了多个插件，且多个插件中有相同的beanName时。即Bean的定义出现冲突时未处理。

欢迎大家在评论区讨论，谢谢阅读。