快捷導(dǎo)航

怎么減少本地調(diào)試tomcat重啟次數(shù)你知道嗎

更新時(shí)間：2022年01月25日 17:19:42 作者：力不竭!!!戰(zhàn)不止!!!

這篇文章主要為大家詳細(xì)介紹了怎么減少本地調(diào)試tomcat重啟次數(shù)，使用Groovy，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下

一招教你如何減少本地調(diào)試tomcat重啟次數(shù)

當(dāng)我們進(jìn)行本地調(diào)試的時(shí)候，代碼做了少量改動(dòng)，卻要重啟tomcat。如果項(xiàng)目比較小還行，如果項(xiàng)目比較大這個(gè)時(shí)候重啟tomcat的時(shí)間就比較長。下面我說的方法將會(huì)讓你減少tomcat不必要的重啟次數(shù)。

這次引入的技術(shù)為Groovy。

在groovy中書寫的代碼無需重啟tomcat，修改之后需需要重新從入口進(jìn)入就行了

什么是Gooovy

Apache Groovy是一種功能強(qiáng)大、可選的類型和動(dòng)態(tài)語言，具有靜態(tài)鍵入和靜態(tài)編譯功能，適用于Java平臺(tái)，旨在通過簡潔、熟悉和易于學(xué)習(xí)的語法提高開發(fā)人員的工作效率。它與任何Java程序順利集成，并立即為您的應(yīng)用程序提供強(qiáng)大的功能，包括腳本功能、特定域語言創(chuàng)作、運(yùn)行時(shí)和編譯時(shí)元編程以及功能編程。和Java兼容性強(qiáng)，可以無縫銜接Java代碼，可以調(diào)用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")
  	//入?yún)ⅲ篻roovy腳本存放絕對(duì)路徑、需要傳遞的參數(shù)
    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();
          //執(zhí)行腳本獲得結(jié)果，約定執(zhí)行的腳本方法名字為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 {
          	//腳本執(zhí)行入口
          	//返回的數(shù)據(jù)類型在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){
      	//注意！?。”镜卣{(diào)試可以不需要加入緩存機(jī)制，生產(chǎn)環(huán)境需要加入緩存
      	//加載腳本，每執(zhí)行一次new一個(gè)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 {
        //靜態(tài)化bean
        this.applicationContext = applicationContext;
        groovyEval = this;
    }
}

Groovy腳本

TestGroovy.groovy

class TestGroovy {
    def Map<String,Object> solution(Map<String,Object> paramMap){
        Map<String,Object> resultMap = [:];
        /** 獲取上層傳入的參數(shù) */
        Object shopCodes = paramMap.get("param");

				//業(yè)務(wù)邏輯處理。。。。。。
				resultMap.put("data", "resultData");
        return resultMap;
    }
}

生產(chǎn)環(huán)境使用

因?yàn)間roovy每執(zhí)行一次腳本，都會(huì)生成一個(gè)腳本的class對(duì)象，這個(gè)class對(duì)象的名字由 “script” + System.currentTimeMillis() +
Math.abs(text.hashCode())組成,因此應(yīng)用到生產(chǎn)環(huán)境需要加入緩存。推薦使用高性能緩存：Caffeine，

官方介紹Caffeine是基于JDK8的高性能本地緩存庫，提供了幾乎完美的命中率。它有點(diǎn)類似JDK中的ConcurrentMap，實(shí)際上，Caffeine中的LocalCache接口就是實(shí)現(xiàn)了JDK中的ConcurrentMap接口，但兩者并不完全一樣。最根本的區(qū)別就是，ConcurrentMap保存所有添加的元素，除非顯示刪除之（比如調(diào)用remove方法）。而本地緩存一般會(huì)配置自動(dòng)剔除策略，為了保護(hù)應(yīng)用程序，限制內(nèi)存占用情況，防止內(nèi)存溢出。

有興趣的可以自己去搜索一下，我感覺蠻好用的

@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{
                //統(tǒng)一返回 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){
        //唯一標(biāo)記
        String cacheKey = DigestUtils.md5Hex(script);
        return caffeine.get(cacheKey, new Function<Object, Object>() {
            @Override
            public Object apply(Object key) {
                //避免變動(dòng)導(dǎo)致并發(fā)問題
                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 {
        //靜態(tài)化 Bean
        this.applicationContext = applicationContext;
        groovyEval = this;
    }
}