Groovy获取Bean两种方式(骚操作)

在Java代码中当我们需要一个Bean对象,通常会使用spring中@Autowired注解,用来自动装配对象。

在Groovy中不能使用@Autowired(autowired是在spring启动后注入的,此时还未加载groovy代码,故无法注入)

一、使用

它与 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

它是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动态脚本Groovy获取Bean(奇淫技巧操作) - 南国以南i - 博客园