看来断点、单步调试还不够硬核，根本没多少人看，这次再来个硬核的。依然是由于apaas平台越来越流行了，如果apaas平台选择了java语言作为平台内的业务代码，那么不仅仅面临着IDE外的断点、单步调试，还面临着为了实现预览效果，需要将写好的java源码动态的装载到spring容器中然后调用源码内的某个方法。这篇文章主要就是实现spring/springboot运行时将源码先编译成class字节码数组，然后字节码数组再经过自定义类加载器变成Class对象，接着Class对象注册到spring容器成为BeanDefinition，再接着直接获取到对象，最后调用对象中指定方法。相信在网上其他地方已经找不到类似的实现了，毕竟像我这样专门做这种别人没有的原创的很少很少，大多都是转载下别人的，或者写些网上一大堆的知识点，哈哈！
个人认为分析复杂问题常见思维方式可以类比软件领域的分治思想，将复杂问题分解成一个个小问题去解决。或者是使用减治思想，将复杂问题每次解决一小部分，留下的问题继续解决一个小部分，这样循环直到问题全部解决。所以软件世界和现实世界确实是想通的，很多思想都可以启迪我们的生活，所以我一直认为一个很会生活的程序员，一个把生活中出现的问题都解决的很好的程序员一定是个好程序员，表示很羡慕这种程序员。
那么我们先分解下这个复杂问题，我们要将一个java类的源码直接加载到spring容器中调用，大致要经历的过程如下：
1、先将java类源码动态编译成字节数组。这一点在java的tools.jar已经有工具可以实现，其实tools.jar工具包真的是一个很好的东西，往往你走投无路不知道怎么实现的功能在tools.jar都有工具，比如断点调试，比如运行时编译，呵呵
2、拿到动态编译的字节码数组后，就需要将字节码加载到虚拟机，生成Class对象。这里应该不难，直接通过自定义一个类加载器就可以搞定
3、拿到Class对象后，再将Class转成Spring的Bean模板对象BeanDefinition。这里可能需要一点spring的知识随便看一点spring启动那里的源码就懂了。
4、使用spring的应用上下文对象ApplicationContext的getBean拿到真正的对象。这个应该用过spring的都知道
5、调用对象的指定方法。这里为了不需要用反射，一般生成的对象都继承一个明确的基类或者实现一个明确的接口，这样就可以由多肽机制，通过接口去接收实现类的引用，然后直接调用指定方法。
下面先看看动态编译的实现,核心源码如下
/**
* 动态编译java源码类
* @author rongdi
* @date 2021-01-06
*/
public class DynamicCompiler { /**
* 编译指定java源代码
* @param javaSrc java源代码
* @return 返回类的全限定名和编译后的class字节码字节数组的映射
*/
public static Map<String, byte[]> compile(String javaSrc) {
Pattern pattern = Pattern.compile("public\\s+class\\s+(\\w+)");
Matcher matcher = pattern.matcher(javaSrc);
if (matcher.find()) {
return compile(matcher.group(1) + ".java", javaSrc);
}
return null;
} /**
* 编译指定java源代码
* @param javaName java文件名
* @param javaSrc java源码内容
* @return 返回类的全限定名和编译后的class字节码字节数组的映射
*/
public static Map<String, byte[]> compile(String javaName, String javaSrc) {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager stdManager = compiler.getStandardFileManager(null, null, null);
try (MemoryJavaFileManager manager = new MemoryJavaFileManager(stdManager)) {
JavaFileObject javaFileObject = manager.makeStringSource(javaName, javaSrc);
JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, Arrays.asList(javaFileObject));
if (task.call()) {
return manager.getClassBytes();
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
} }
然后就是自定义类加载器的实现了
/**
* 自定义动态类加载器
* @author rongdi
* @date 2021-01-06
*/
public class DynamicClassLoader extends URLClassLoader { Map<String, byte[]> classBytes = new HashMap<String, byte[]>(); public DynamicClassLoader(Map<String, byte[]> classBytes) {
super(new URL[0], DynamicClassLoader.class.getClassLoader());
this.classBytes.putAll(classBytes);
} /**
* 对外提供的工具方法，加载指定的java源码，得到Class对象
* @param javaSrc java源码
* @return
*/
public static Class<?> load(String javaSrc) throws ClassNotFoundException {
/**
* 先试用动态编译工具，编译java源码，得到类的全限定名和class字节码的字节数组信息
*/
Map<String, byte[]> bytecode = DynamicCompiler.compile(javaSrc);
if(bytecode != null) {
/**
* 传入动态类加载器
*/
DynamicClassLoader classLoader = new DynamicClassLoader(bytecode);
/**
* 加载得到Class对象
*/
return classLoader.loadClass(bytecode.keySet().iterator().next());
} else {
throw new ClassNotFoundException("can not found class");
}
} @Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] buf = classBytes.get(name);
if (buf == null) {
return super.findClass(name);
}
classBytes.remove(name);
return defineClass(name, buf, 0, buf.length);
} }
接下来就是将源码编译、加载、放入spring容器的工具了
package com.rdpaas.core.utils; import com.rdpaas.core.compiler.DynamicClassLoader;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext; /**
* 基于spring的应用上下文提供一些工具方法
* @author rongdi
* @date 2021-02-06
*/
public class ApplicationUtil { /**
* 注册java源码代表的类到spring容器中
* @param applicationContext
* @param src
*/
public static void register(ApplicationContext applicationContext, String src) throws ClassNotFoundException {
register(applicationContext, null, src);
} /**
* 注册java源码代表的类到spring容器中
* @param applicationContext
* @param beanName
* @param src
*/
public static void register(ApplicationContext applicationContext, String beanName, String src) throws ClassNotFoundException { /**
* 使用动态类加载器载入java源码得到Class对象
*/
Class<?> clazz = DynamicClassLoader.load(src); /**
* 如果beanName传null，则赋值类的全限定名
*/
if(beanName == null) {
beanName = clazz.getName();
} /**
* 将applicationContext转换为ConfigurableApplicationContext
*/
ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) applicationContext;
/**
* 获取bean工厂并转换为DefaultListableBeanFactory
*/
DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
/**
* 万一已经有了这个BeanDefinition了，先remove掉,不然一次容器启动没法多次调用,这里千万别用成
* defaultListableBeanFactory.destroySingleton()了，BeanDefinition的注册只是放在了beanDefinitionMap中，还没有
* 放入到singletonObjects这个map中，所以不能用destroySingleton()，这个是没效果的
*/
if (defaultListableBeanFactory.containsBeanDefinition(beanName)) {
defaultListableBeanFactory.removeBeanDefinition(beanName);
}
/**
* 使用spring的BeanDefinitionBuilder将Class对象转成BeanDefinition
*/
BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
/**
* 以指定beanName注册上面生成的BeanDefinition
*/
defaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getRawBeanDefinition()); } /**
* 使用spring上下文拿到指定beanName的对象
*/
public static <T> T getBean(ApplicationContext applicationContext, String beanName) {
return (T) ((ConfigurableApplicationContext) applicationContext).getBeanFactory().getBean(beanName);
} /**
* 使用spring上下文拿到指定类型的对象
*/
public static <T> T getBean(ApplicationContext applicationContext, Class<T> clazz) {
return (T) ((ConfigurableApplicationContext) applicationContext).getBeanFactory().getBean(clazz);
} }
再给出一些必要的测试类
package com.rdpaas.core.dao; import org.springframework.stereotype.Component; /**
* 模拟一个简单的dao实现
* @author rongdi
* @date 2021-01-06
*/
@Component
public class TestDao { public String query(String msg) {
return "msg:"+msg;
} }
package com.rdpaas.core.service; import com.rdpaas.core.dao.TestDao;
import org.springframework.beans.factory.annotation.Autowired; /**
* 模拟一个简单的service抽象类，其实也可以是接口，主要是为了把dao带进去，
* 所以就搞了个抽象类在这里
* @author rongdi
* @date 2021-01-06
*/
public abstract class TestService { @Autowired
protected TestDao dao; public abstract String sayHello(String msg); }
最后就是测试的入口类了
package com.rdpaas.core.controller; import com.rdpaas.core.service.TestService;
import com.rdpaas.core.utils.ApplicationUtil;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody; /**
* 测试入口类
* @author rongdi
* @date 2021-01-06
*/
@Controller
public class DemoController implements ApplicationContextAware { private static String javaSrc = "package com;" +
"public class TestClass extends com.rdpaas.core.service.TestService{" +
" public String sayHello(String msg) {" +
" return \"我查到了数据,\"+dao.query(msg);" +
" }" +
"}"; private ApplicationContext applicationContext; @Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
} /**
* 测试接口，实际上就是完成动态编译java源码、加载字节码变成Class，装载Class到spring容器，
* 获取对象，调用对象的测试
* @return
* @throws Exception
*/
@RequestMapping("/test")
@ResponseBody
public String test() throws Exception {
/**
* 美滋滋的注册源码到spring容器得到一个对象
* ApplicationUtil.register(applicationContext, javaSrc);
*/
ApplicationUtil.register(applicationContext,"testClass", javaSrc);
/**
* 从spring上下文中拿到指定beanName的对象
* 也可以 TestService testService = ApplicationUtil.getBean(applicationContext,TestService.class);
*/
TestService testService = ApplicationUtil.getBean(applicationContext,"testClass"); /**
* 直接调用
*/
return testService.sayHello("haha");
} }
想想应该有点激动了，使用这套代码至少可以实现如下风骚的效果
1、开放一个动态执行代码的入口，将这个代码内容放在一个post接口里提交过去，然后直接执行返回结果
2、现在你有一个apaas平台，里面的业务逻辑使用java代码实现，写好保存后，直接放入spring容器，至于执行不执行看你自己业务了
3、结合上一篇文章的断点调试，你现在已经可以实现在自己平台使用java代码写逻辑，并且支持断点和单步调试你的java代码了
好了，这次的主题又接近尾声了，如果对我的文章感兴趣或者需要详细源码，请支持一下我的同名微信公众号，方便大家可以第一时间收到文章更新，同时也让我有更大的动力继续保持强劲的热情，替大家解决一些网上搜索不到的问题，当然如果有啥想让我研究的，也可以文章留言或者公众号发送信息。如果有必要，我会花时间替大家研究研究。