怎么减少本地调试tomcat重启次数你知道吗

一招教你如何减少本地调试tomcat重启次数

当我们进行本地调试的时候，代码做了少量改动，却要重启tomcat。如果项目比较小还行，如果项目比较大这个时候重启tomcat的时间就比较长。下面我说的方法将会让你减少tomcat不必要的重启次数。

这次引入的技术为Groovy。

在groovy中书写的代码无需重启tomcat，修改之后需需要重新从入口进入就行了

什么是Gooovy

ApacheGroovy是一种功能强大、可选的类型和动态语言，具有静态键入和静态编译功能，适用于Java平台，旨在通过简洁、熟悉和易于学习的语法提高开发人员的工作效率。它与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本功能、特定域语言创作、运行时和编译时元编程以及功能编程。和Java兼容性强，可以无缝衔接Java代码，可以调用Java所有的库。

多得不说，直接上代码

pom依赖

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-jsr223</artifactId>
    <version>3.0.6</version>
</dependency>

Controller

@Controller
@Slf4j
public class ScriptAction {
    @Autowired
    private GroovyEval groovyEval;

    @RequestMapping(value = "/script/test")
  	//入参：groovy脚本存放绝对路径、需要传递的参数
    public Object scriptTest(
            @Param(value = "path", required = true) String path,
            @Json("@requestBody") @RequestBody Map<String,Object> paramMap
            ) {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8));
            String date;
            StringBuilder stringBuilder = new StringBuilder();
            while((date = bufferedReader.readLine()) != null){
                stringBuilder.append(date).append("\n");
            }
            bufferedReader.close();
          //执行脚本获得结果，约定执行的脚本方法名字为solution
            return groovyEval.evalScript(bufferedReader.toString() , "solution" , new Object[]{paramMap});
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Service

import com.google.gson.Gson;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class GroovyEval implements ApplicationContextAware {
    private static GroovyEval groovyEval;
    private ApplicationContext applicationContext;
    public static <T> T getBean(Class<T> cls){
        return groovyEval.applicationContext.getBean(cls);
    }
    public Object evalScript(String script, String methodName, Object[] args){
        Object scriptObj = this.getScript(script);
        try {
          	//脚本执行入口
          	//返回的数据类型在groovy脚本中自己定义即可，我这里返回的是map
            Map<String, Object> resultMap = (Map<String, Object>)((GroovyObject)scriptObj).invokeMethod(methodName, args);
            if (CollectionUtils.isEmpty(resultMap)){
                return null;
            }
            return resultMap.get("data");
        } catch (Throwable e) {
            log.error("script eval error !" , e);
        }
        return null;
    }

    private Object getScript(String script){
      	//注意！！！本地调试可以不需要加入缓存机制，生产环境需要加入缓存
      	//加载脚本，每执行一次new一个GroovyCodeSource
        Class<?> cls = new GroovyClassLoader().parseClass(script);
        GroovyObject groovyObject = null;
        try {
            log.info("load script!");
         groovyObject = (GroovyObject)cls.newInstance();
        } catch (IllegalAccessException | InstantiationException e) {
            log.error("load script error ! script : {}" , script , e);
        }
        return groovyObject;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //静态化bean
        this.applicationContext = applicationContext;
        groovyEval = this;
    }
}

Groovy脚本

TestGroovy.groovy

class TestGroovy {
    def Map<String,Object> solution(Map<String,Object> paramMap){
        Map<String,Object> resultMap = [:];
        /** 获取上层传入的参数 */
        Object shopCodes = paramMap.get("param");

				//业务逻辑处理。。。。。。
				resultMap.put("data", "resultData");
        return resultMap;
    }
}

生产环境使用

因为groovy每执行一次脚本，都会生成一个脚本的class对象，这个class对象的名字由 “script” + System.currentTimeMillis() +
Math.abs(text.hashCode())组成,因此应用到生产环境需要加入缓存。推荐使用高性能缓存：Caffeine，

官方介绍Caffeine是基于JDK8的高性能本地缓存库，提供了几乎完美的命中率。它有点类似JDK中的ConcurrentMap，实际上，Caffeine中的LocalCache接口就是实现了JDK中的ConcurrentMap接口，但两者并不完全一样。最根本的区别就是，ConcurrentMap保存所有添加的元素，除非显示删除之（比如调用remove方法）。而本地缓存一般会配置自动剔除策略，为了保护应用程序，限制内存占用情况，防止内存溢出。

有兴趣的可以自己去搜索一下，我感觉蛮好用的

@Component
public class GroovyEval implements ApplicationContextAware {
    private static final Logger LOGGER = LoggerFactory.getLogger(GroovyEval.class);
    private static final Object source = new Object();
    private static GroovyEval groovyEval;
    private ApplicationContext applicationContext;
    @Autowired
    private AlarmThresholdSettingsItemService alarmThresholdSettingsItemService;
    public static <T> T getBean(Class<T> cls){
        return groovyEval.applicationContext.getBean(cls);
    }
    private static final Cache<Object, Object> caffeine = Caffeine
            .newBuilder()
            .maximumSize(30000)
            //三天不用直接 gc
            .expireAfterAccess(72 , TimeUnit.HOURS)
            .build();
    public Map lookUp(){
        return caffeine.asMap();
    }
    public Object evalScript(String script,String methodName,Object[] args) {
        Object scriptObj = this.getScript(script);
        if(scriptObj != null){
            try{
                //统一返回 Map<String,Object>   { "data" : object }
                Map<String, Object> resultMap = (Map<String, Object>) ((GroovyObject) scriptObj).invokeMethod(methodName, args);
                if(CollectionUtils.isEmpty(resultMap)){
                    return null;
                }
                return resultMap.get("data");
            }catch (Throwable e){
                LOGGER.error("script eval error !" , e);
            }
        }
        return null;
    }
  	//脚本加入缓存
    private Object getScript(String script){
        //唯一标记
        String cacheKey = DigestUtils.md5Hex(script);
        return caffeine.get(cacheKey, new Function<Object, Object>() {
            @Override
            public Object apply(Object key) {
                //避免变动导致并发问题
                synchronized (source){
                    Class<?> cls = new GroovyClassLoader().parseClass(script);
                    GroovyObject gObj = null;
                    try {
                        LOGGER.info("load script !");
                        gObj = (GroovyObject) cls.newInstance();
                    } catch (InstantiationException | IllegalAccessException e) {
                        LOGGER.error("load script error ! script : {}" , script , e);
                    }
                    return gObj;
                }
            }
        });
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //静态化 Bean
        this.applicationContext = applicationContext;
        groovyEval = this;
    }
}

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!