Java动态脚本Groovy获取Bean技巧

目录

• 一、使用BeanFactoryPostProcessor注入Bean：

• 第一步：创建实现SpringUtils 接口工具（组件）来获取spring bean

• 第二步：创建Groovy脚本装载类，动态解析脚本为Class

• 第三步：读取脚本内容，执行脚本

• 第四步：在resources目录下创建.groovy文件

• 第五步：实例化脚本，执行方法 

• 二、使用ApplicationContext注入Bean

• 第一步：修改项目启动类，获得ApplicationContext

• 第二步：修改resources目录下创建的.groovy文件

在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())
   }

脚本运行结果：

来源：https://www.cnblogs.com/bg