Java動態腳本Groovy獲取Bean（奇淫技巧操作）

前言：請各大網友尊重本人原創知識分享，謹記本人博客：南國以南i

背景：

在Java代碼中當我們需要一個Bean物件，通常會使用spring中@Autowired注解，用來自動裝配物件，

在Groovy中不能使用@Autowired（autowired是在spring啟動后注入的，此時還未加載groovy代碼，故無法注入）

一、使用BeanFactoryPostProcessor注入Bean：

它與 BeanPostProcessor介面類似,可以對bean的定義(配置元資料)進行處理；也就是spring ioc運行BeanFactoryPostProcessor在容器實體化任何其他的bean之前讀取配置元資料,并有可能修改它；如果業務需要，可以配置多個BeanFactoryPostProcessor的實作類，通過"order"控制執行次序(要實作Ordered介面)，

第一步：創建實作SpringUtils 介面工具（組件）來獲取spring bean

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

@Component
public class SpringUtils implements BeanFactoryPostProcessor {

    /** Spring應用背景關系環境 \*/
    private static ConfigurableListableBeanFactory beanFactory;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
        SpringUtils.beanFactory = beanFactory;
    }
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }
}

第二步：創建Groovy腳本裝載類，動態決議腳本為Class

package com.example.groovy.testgroovy.task;

import groovy.lang.GroovyClassLoader;

public class GroovyUtils {

    private final static ClassLoader classLoader = GroovyUtils.class.getClassLoader();//獲取當前類裝載器
    //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) taskClz.newInstance();
        return instance;
    }
}

第三步：讀取腳本內容，執行腳本

@Slf4j
@Component
public class CallAnalysisGroovyTask {


    /**
     * .
     * 讀取腳本內容
     *
     * @return
     */
    public String getGroovy() {
        String context = "";
        try {
            String path = "E:\\IDEAFile\\testgroovy\\src\\main\\resources\\groovy\\LoadBean.groovy";
            context = FileUtils.readFileToString(new File(path));//將腳本內容轉為字串
        } catch (IOException e) {
            log.error("file is not found[{}]", e);
        }
        return context;
    }

    /**
     * .
     * 執行groovy腳本
     *
     * @param script
     */
    public void execGroovy(String script) {
        try {
            Runnable runnable = GroovyUtils.instanceTaskGroovyScript(script);//獲取實體物件
            runnable.run();//呼叫腳本方法
        } catch (Exception t) {
            log.error("execGroovy file {} error", script);
        }
    }
}

第四步：在resources目錄下創建.groovy檔案

@Slf4j
class LoadBean implements Runnable {

    /**
     * .
     * Groovy獲取Bean
     */
    @Override
    void run() {
        log.info("Groovy開始執行,當前類{}", this.getClass())
        ScriptService service = SpringUtils.getBean(ScriptService.class)
        log.info("ApplicationContext獲取物件[{}]", service.class)
        List<Script> item = service.findAll()//執行bean中資料查詢方法
        for (Script s : item) {
            log.info("創建人:[{}],規則id:[{}],名稱:[{}]", s.getCreatePerson(), s.getRuleId(), s.getScriptName())
        }
        log.info("Groovy結束執行,當前類{}", this.getClass())
    }
}

第五步：實體化腳本，執行方法

    @GetMapping("/loadBean")
    public void loadBean(){
        String script = CallAnalysisGroovyTask.getGroovy(); //獲取腳本
        CallAnalysisGroovyTask.execGroovy(script);//實體化腳本，執行方法
        log.info("資料查詢成功...");
    }

腳本運行結果：

二、使用ApplicationContext注入Bean

它是spring繼BeanFactory之外的另一個核心介面或容器，允許容器通過應用程式背景關系環境創建、獲取、管理bean，為應用程式提供配置的中央介面，在應用程式運行時這是只讀的，但如果實作支持這一點，則可以重新加載，

第一步：修改專案啟動類，獲得ApplicationContext

@SpringBootApplication
public class TestgroovyApplication {

    //獲取應用程式背景關系環境
    private static ApplicationContext applicationContext;

    public static void main(String[] args) {
        applicationContext = SpringApplication.run(TestgroovyApplication.class, args);
    }

第二步：修改resources目錄下創建的.groovy檔案

    /**
     * .
     * Groovy獲取Bean
     */
    @Override
    void run() {
        log.info("Groovy開始執行,當前類{}", this.getClass())
        ScriptService service = TestgroovyApplication.applicationContext.getBean(ScriptService.class)
        log.info("ApplicationContext獲取物件[{}]", service.class)
        List<Script> item = service.findAll()//執行bean中資料查詢方法
        for (Script s : item) {
            log.info("創建人:[{}],規則id:[{}],名稱:[{}]", s.getCreatePerson(), s.getRuleId(), s.getScriptName())
        }
        log.info("Groovy結束執行,當前類{}", this.getClass())
    }

腳本運行結果：

參考連接

標籤：Java

上一篇：java~RMI引起的log4j漏洞

下一篇：Log4j2 重大漏洞，編譯好的log4j-2.15.0.jar包下載