怎麼減少本地調試tomcat重啟次數你知道嗎

Posted on by

一招教你如何減少本地調試tomcat重啟次數

當我們進行本地調試的時候，代碼做瞭少量改動，卻要重啟tomcat。如果項目比較小還行，如果項目比較大這個時候重啟tomcat的時間就比較長。下面我說的方法將會讓你減少tomcat不必要的重啟次數。

這次引入的技術為Groovy。

在groovy中書寫的代碼無需重啟tomcat，修改之後需需要重新從入口進入就行瞭

什麼是Gooovy

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;
    }
}

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容!     

推薦閱讀：