一招教你如何减少本地调试tomcat重启次数，亲测有效

柔情只为你懂 2024-04-22 06:36 43阅读 0赞

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

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

**这次引入的技术为Groovy。**

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

### 什么是Gooovy ###

[Apache ][Apache]Groovy是一种**功能强大**、**可选的类型**和**动态**语言，具有**静态键入和静态编译**功能，适用于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;
        }
    
    }

[Apache]: http://www.apache.org/