Java动态脚本Groovy
⽬录
1.Groovy特性
2.核⼼涉及
3.Java与Groovy转换
第⼀步：引⼊Groovy依赖
第⼆步：创建interface接⼝声明⽅法
第三步：在resources⽬录下创建.groovy⽂件
第四步：创建Groovy脚本装载类，动态解析脚本为Class
第五步：读取脚本内容，执⾏脚本
4.Groovy特性验证
第⼀步：将之前Groovy脚本数据修改。存于数据库表中，动态加载脚本
第⼆步：数据库表中：添加、查询Groovy脚本，动态加载执⾏
第三步：多次修改表数据值，查看执⾏结果
5.总语
1.Groovy特性
可将java代码在Groovy脚本动态编码、代码被修改达到不重启服务的⽬的（类似于热部署）
2.核⼼涉及
ClassLoader：就是类的装载器，它使JVM可以动态的载⼊Java类，JVM并不需要知道从什么地⽅（本地⽂件、⽹络等）载⼊Java 类，这些都由ClassLoader完成。
GroovyClassLoader：动态地加载⼀个脚本并执⾏它的⾏为。GroovyClassLoader是⼀个定制的类装载器，负责解释加载Java类中⽤到的Groovy类。
3.Java与Groovy转换
第⼀步：引⼊Groovy依赖
<!--Groovy脚本依赖-->
<dependency>
<groupId&vy</groupId>
<artifactId>groovy</artifactId>
<version>2.5.14</version>
</dependency>
第⼆步：创建interface接⼝声明⽅法
public interface CallAnalysis {
default void load() {
}
}
第三步：在resources⽬录下创建.groovy⽂件
package groovy
stgroovy.task.CallAnalysis
import groovy.util.logging.Slf4j
@Slf4j
class CallAnalysisImpl implements CallAnalysis{
@Override
void load() {
log.info("我被Groovy脚本加载...")
}
}
第四步：创建Groovy脚本装载类，动态解析脚本为Class
stgroovy.task;
import groovy.lang.GroovyClassLoader;
public class GroovyUtils {
private final static ClassLoader classLoader = ClassLoader();//获取当前类装载器
//ClassLoader：就是类的装载器，它使JVM可以动态的载⼊Java类，JVM并不需要知道从什么地⽅（本地⽂件、⽹络等）载⼊Java类，这些都由ClassLoader完成。 public final static GroovyClassLoader groovyClassLoader = new GroovyClassLoader(classLoader);
//GroovyClassLoader：负责在运⾏时编译groovy源代码为Class的⼯作，从⽽使Groovy实现了将groovy源代码动态加载为Class的功能。
/**
* .
* 获取实例化对象
* @param script groovy脚本内容
* @param <T>
* @return
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static <T> T instanceTaskGroovyScript(String script) throws IllegalAccessException, InstantiationException {
Class taskClz = groovyClassLoader.parseClass(script);
T instance = (T) wInstance();
return instance;
}
}
第五步：读取脚本内容，执⾏脚本
stgroovy.task;
slf4j.Slf4j;
import org.apachemons.io.FileUtils;
import org.springframework.stereotype.Component;
import java.io.File;
import java.io.IOException;
@Slf4j
@Component
public class CallAnalysisGroovyTask {
/**
* .
* 读取脚本内容
*
* @return
*/
public static String getGroovy() {
String context = "";
try {
String path = "E:\\IDEAFile\\testgroovy\\src\\main\\resources\\groovy\\vy";
context = adFileToString(new File(path));//将脚本内容转为字符串
} catch (IOException e) {
<("file is not found[{}]", e);
}
return context;
}
/**
* .
* 执⾏groovy脚本
*
* @param script
*/
public static void execGroovy(String script) {
try {
CallAnalysis objClass = GroovyUtils.instanceTaskGroovyScript(script);//获取实例对象
objClass.load();//调⽤脚本⽅法
} catch (Exception t) {
<("execGroovy file {} error", script);
}
}
/**
* .
* main⽅法
* @param args
*/
public static void main(String[] args) {
System.out.println("==================");
CallAnalysisGroovyTask task = new CallAnalysisGroovyTask();
String script = Groovy();//获取脚本
execGroovy(script);//实例化脚本，执⾏⽅法
System.out.println("==================");
}
}
4.Groovy特性验证
利⽤Groovy脚本特性，不重启服务，实时修改数据
第⼀步：将之前Groovy脚本数据修改。存于数据库表中，动态加载脚本@Slf4j
class CallAnalysisImpl implements CallAnalysis {
private int anInt = 10;
private int bnInt = 10;
@Override
void load() {
log.info("当前类:[{}]", Class().getName())
log.info("我被Groovy脚本加载...")
log.info("计算结果:[{}]", (anInt + bnInt))
}
}
第⼆步：数据库表中：添加、查询Groovy脚本，动态加载执⾏
/**
* .
* 读取脚本，进⾏⼊库操作
*
* @return
*/
@GetMapping("/saveScript")
public String saveScript() {
String scriptStr = Groovy();
Script script = new Script();//实体类对象
script.setScript(scriptStr);//脚本内容
script.setRuleId("1");//规则id
script.setScriptName("演⽰⼀");//脚本名称
service.save(script);
return "添加成功";
}
/**
* .
* 从数据库表中，动态获取脚本
*
* @param ruleId 规则id
* @return 脚本内容
*/
@GetMapping("/groovy")
public String groovy(final String ruleId) {
Script scr = scriptService.findScriptByRuleId(ruleId);//根据规则id查询
String scriptStr = Script();
return scriptStr;
}
添加结果:
查询结果、控制台执⾏结果:
java集合排序怎么实现第三步：多次修改表数据值，查看执⾏结果
5.总语
⽬的达成，可见在不重启服务时，多次修改数据，脚本内容都会被动态加载。此处只是简单举例验证，可⾃⾏扩展
到此这篇关于Java动态脚本Groovy的⽂章就介绍到这了，更多相关Java动态脚本Groovy内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论