从零搭建开发脚手架 Spring Boot 集成Groovy实现动态加载业务规则

一时失言乱红尘 2022-08-30 05:28 409阅读 0赞

### 文章目录 ###

*   *  背景
     *   *  什么是 Groovy？
     *  使用体验
     *   *  1、利用Spring Boot的\`CommandLineRunner\`注册SpringBean、GroovyBean
         *  2、项目内不变的规则以Java实现继承RuleFilter
         *  3、项目内经常变动的以Groovy来实现
         *  4、在合适的位置使用RuleFilterProcessor
         *  5、启动并验证
     *  实现
     *  总结

## 背景 ##

前端时间体验了Zuul的groovy Filter，其实现了动态热加载Filter，**可以在不重启应用的情况下新增和更新自己的业务规则**，现在我也来仿照Zuul来山寨一个，用于我们日常多变的业务规则中。

**需要依赖groovy-all**

<dependency>
                <groupId>org.codehaus.groovy</groupId>
                <artifactId>groovy-all</artifactId>
                <version>2.4.12</version> 版本自己去适配哈
            </dependency>

### 什么是 Groovy？ ###

类似于Python，perl等**灵活动态语言**，不过它是**运行在java平台上**，也就是**Groovy最后代码会被编译成class字节码文件**，集成到web应用或者java应用中，groovy编写的程序其实就是特殊点的Java程序，而且java类库可以在groovy中直接使用。

Groovy 的另一个好处是，它的语法与 Java 语言的语法很相似。

## 使用体验 ##

**先来体验下实现后的成果**

### 1、利用Spring Boot的`CommandLineRunner`注册SpringBean、GroovyBean ###

*  初始化加载项目中RuleFilter的`Spring Bean`
    
     *  直接使用`@Autowired`注解配合`List`即可获取所有`RuleFilter`的子类
 *  初始化`Groovy`动态扫描的监控间隔，目录配置
    
     *  这里配置的是每5秒检查`D:\\laker\\lakernote\\groovy`目录下，新增或者修改的文件用于编译加载
     *  初始化也会加载`D:\\laker\\lakernote\\groovy`目录下文件。

@Component
    public class GroovyRunner implements CommandLineRunner { 
        @Autowired
        List<RuleFilter> ruleFilterList;
        @Override
        public void run(String... args) throws Exception { 
            // 初始化加载项目中RuleFilter的Springbean
            RuleFilterLoader.getInstance().initSpringRuleFilter(ruleFilterList);
            try { 
                // 每隔多少秒，扫描目录下的groovy文件
                RuleFilterFileManager.init(5, "D:\\laker\\lakernote\\groovy");
            } catch (Exception e) { 
                e.printStackTrace();
                throw new RuntimeException();
            }
        }
    }

### 2、项目内不变的规则以Java实现继承RuleFilter ###

这个就是普通的Java类，我们把不变的规则以这种方式实现。

@Component
    public class JavaRule extends RuleFilter { 
        /** * 具体规则执行 * @param msg */
        @Override
        public void run(String msg) { 
            System.out.println(" === Java 实现的业务规则 order = 1 ， msg = " + msg + " === ");
        }
        /** * 该规则是否被执行 * @return */
        @Override
        public boolean shouldRun() { 
            return true;
        }
    
        /** * 该规则执行的顺序 * @return */
        @Override
        public int runOrder() { 
            return 1;
        }
    }

### 3、项目内经常变动的以Groovy来实现 ###

groovy兼容Java语法，可以直接用java语法来写。

public class GroovyRule extends RuleFilter { 
        @Override
        public void run(String msg) { 
    
            System.out.println(" === Groovy 实现的业务规则 order = " + runOrder() + "， msg = " + msg + " === ");
        }
        @Override
        public boolean shouldRun() { 
            return true;
        }
        @Override
        public int runOrder() { 
            return 2;
        }
    }

> 然后把这个xxx.java文件丢到我们监控的文件夹即可

### 4、在合适的位置使用RuleFilterProcessor ###

这里我写了个`Controller`用来测试动态加载规则。

@RestController
    @RequestMapping("/groovy")
    public class GroovyController { 
        @Autowired
        private RuleFilterProcessor ruleFilterProcessor;
    
        @GetMapping()
        @ApiOperation("测试groovy的动态加载")
        public void transaction(@RequestParam String msg) { 
            ruleFilterProcessor.runRuleFilters(msg);
        }
    }

### 5、启动并验证 ###

我分了几个场景验证如下：

**1. 启动程序**

浏览器访问：`http://localhost:8080/groovy?msg=laker%20666`

**结果如下：**

=== Java 实现的业务规则 order = 1 ， msg = laker 666 === 
     === Groovy 实现的业务规则 order = 2 ， msg = laker 666 ===

**2. 我修改GroovyRule中的runOrder()，把它改为0**

> 不用重启服务

浏览器访问：`http://localhost:8080/groovy?msg=laker%20666`

**结果如下：**

=== Groovy 实现的业务规则 order = 0 ， msg = laker 666 === 
     === Java 实现的业务规则 order = 1 ， msg = laker 666 ===

**3. 我新增一个Groovy2Rule然后丢进上面指定的监控文件夹**

public class Groovy2Rule extends RuleFilter { 
        @Override
        public void run(String msg) { 
            System.out.println(" === Groovy 实现的业务规则 order = " + runOrder() + "， msg = " + msg + " === ");
            List<RuleFilter> ruleFilters = RuleFilterLoader.getInstance().getFilters();
            for (RuleFilter ruleFilter : ruleFilters) { 
                System.out.println(ruleFilter.getClass().getName());
            }
        }
        @Override
        public boolean shouldRun() { 
            return true;
        }
    
        @Override
        public int runOrder() { 
            return 3;
        }
    }

> 不用重启服务

浏览器访问：`http://localhost:8080/groovy?msg=laker%20666`

**结果如下：**

=== Groovy 实现的业务规则 order = 0 ， msg = laker 666 === 
     === Java 实现的业务规则 order = 1 ， msg = laker 666 === 
     === Groovy 实现的业务规则 order = 3， msg = laker 666 === 
    com.laker.map.moudle.groovy.javarule.GroovyRule
    com.laker.map.moudle.groovy.javarule.JavaRule
    com.laker.map.moudle.groovy.Groovy2Rule

> 这里如果想调用Spring环境中的bean可以借助SpringContextUtil

## 实现 ##

**核心的模块如下**

*  `RuleFilter` ：规则过滤器抽象类，用于扩展实现业务规则，供Java和Groovy继承。
 *  `RuleFilterLoader` ： 规则过滤器加载器，用于加载基于`Spring`的`RuleFilter`实现类和动态编译指定文件基于`Groovy`的`RuleFilter`实现类。
    
     *  存储所有的规则过滤器并能动态加载改变的和新增的规则。
 *  `RuleFilterFileManager` : 一个独立线程轮询监听指定目录文件的变化配合`RuleFilterLoader` （ 规则过滤器加载器）使用。
 *  `RuleFilterProcessor`: 业务规则处理器核心入口

> 这四个核心模块都是盗版Zuul的实现。

**贴上部分核心代码如下：**

**RuleFilter.java**

public abstract class RuleFilter implements IRule, Comparable<RuleFilter> { 
    
        abstract public int runOrder();
    
        @Override
        public int compareTo(RuleFilter ruleFilter) { 
            return Integer.compare(this.runOrder(), ruleFilter.runOrder());
        }
        ...
    }

**RuleFilterLoader.java**

public class RuleFilterLoader { 
        public boolean putFilter(File file) throws Exception { 
            String sName = file.getAbsolutePath() + file.getName();
            if (filterClassLastModified.get(sName) != null && (file.lastModified() != filterClassLastModified.get(sName))) { 
                LOG.debug("reloading filter " + sName);
                filterRegistry.remove(sName);
            }
            RuleFilter filter = filterRegistry.get(sName);
            if (filter == null) { 
                Class clazz = compile(file);
                if (!Modifier.isAbstract(clazz.getModifiers())) { 
                    filter = (RuleFilter) clazz.newInstance();
                    filterRegistry.put(file.getAbsolutePath() + file.getName(), filter);
                    ruleFilters.clear();
                    filterClassLastModified.put(sName, file.lastModified());
                    return true;
                }
            }
            return false;
        }
        public List<RuleFilter> getFilters() { 
            if (CollUtil.isNotEmpty(ruleFilters)) { 
                return ruleFilters;
            }
            ruleFilters.addAll(springRuleFilterList);
            ruleFilters.addAll(this.filterRegistry.values());
            Collections.sort(ruleFilters);
            return ruleFilters;
        }
        private Class compile(File file) throws IOException { 
            GroovyClassLoader loader = getGroovyClassLoader();
            Class groovyClass = loader.parseClass(file);
            return groovyClass;
        }
        GroovyClassLoader getGroovyClassLoader() { 
            return new GroovyClassLoader();
        }
        ...
    }

**RuleFilterFileManager.java**

public class RuleFilterFileManager { 
        public static void init(int pollingIntervalSeconds, String... directories)  { 
            if (INSTANCE == null) INSTANCE = new RuleFilterFileManager();
    
            INSTANCE.aDirectories = directories;
            INSTANCE.pollingIntervalSeconds = pollingIntervalSeconds;
            INSTANCE.manageFiles();
            INSTANCE.startPoller();
        }
        void startPoller() { 
            poller = new Thread("GroovyRuleFilterFileManagerPoller") { 
                @Override
                public void run() { 
                    while (bRunning) { 
                        try { 
                            sleep(pollingIntervalSeconds * 1000);
                            manageFiles();
                        } catch (Exception e) { 
                            e.printStackTrace();
                        }
                    }
                }
            };
            poller.setDaemon(true);
            poller.start();
        }
       void processGroovyFiles(List<File> aFiles) throws Exception, InstantiationException, IllegalAccessException { 
    
            for (File file : aFiles) { 
                RuleFilterLoader.getInstance().putFilter(file);
            }
        }
        void manageFiles() throws Exception, IllegalAccessException, InstantiationException { 
            List<File> aFiles = getFiles();
            processGroovyFiles(aFiles);
        }
        ...
    }

**RuleFilterProcessor.java**

@Component
    public class RuleFilterProcessor { 
        public void runRuleFilters(String msg) { 
            List<RuleFilter> list = RuleFilterLoader.getInstance().getFilters();
            if (list != null) { 
                list.forEach(ruleFilter -> { 
                    if (ruleFilter.shouldRun()) { 
                        ruleFilter.run(msg);
                    }
                });
            }
        }
    }

## 总结 ##

可以看到使用起来是相当的方便，仅依赖`groovy-all`，整体代码结构简单。

**性能和稳定性未测试**，但是这基本就是翻版的Zuul，Zuul都在使用了，应该没什么问题。

**参考：**

*  参考了Zuul源码，比较简单，建议大家都去看看。